@buerli.io/headless 0.10.0 → 0.11.0

package/build/types/history.d.ts

@@ -1,1641 +1,1643 @@
-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, GeometryElement } from '@buerli.io/core';
-import { BufferGeometry, Material, Object3D, Scene } from 'three';
-/**
- * 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
- * expressions which you can alter at a later time, prompting your model to re-calculate.
- * Use this for assembly and variant configurators.
- *
- * > The history modeling approach relies heavily on the underlying `assemblyBuilder ClassCAD API`.
- * Since this part of the API is still under construction, the interfaces of the history functions
- * can still change.
- *
- * ```sh
- * npm install @buerli.io/headless
- * ```
- *
- * ```js
- * import { history } from '@buerli.io/headless'
- * const cad = new history(url)
- * cad.init(async api => {
- *     // Your code goes here
- * })
- * ```
- */
-export declare type ApiHistory = {
-    /**
-     * 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, identifier or name of the product to instantiate
-     * @param ownerId id, identifier or name 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
-     */
-    addInstances: (...instances: {
-        productId: VID | ObjectIdent;
-        ownerId: VID | ObjectIdent;
-        transformation: Transform;
-        name?: string;
-        options?: {
-            ident?: ObjectIdent;
-        };
-    }[]) => Promise<ObjectID[] | null>;
-    /**
-     * Adds multiple dimensions to products in the 3D view
-     * @param dimensions dimensions to be added to products
-     * @example
-     * // Get the current product
-     * const productId = await api.getCurrentProduct()
-     *
-     * // Create dimensions
-     * const dimension1: DimensionType = {
-     *   productId: productId,
-     *   dimParam: {
-     *     dimType: 'LinearDimension',
-     *     dimLabel: 'Breite = ',
-     *     dimStartPos: { x: 0, y: 0, z: 0 },
-     *     dimEndPos: { x: 100, y: 0, z: 0 },
-     *     dimTextPos: { x: 50, y: -10, z: 0 },
-     *     dimTextAngle: 0,
-     *     dimOrientation: 'Horizontal',
-     *   },
-     *   dxfView: 'Top',
-     * }
-     *
-     * const dimension2: DimensionType = {
-     *   productId: productId,
-     *   dimParam: {
-     *     dimType: 'LinearDimension',
-     *     dimLabel: 'Laenge = ',
-     *     dimStartPos: { x: 0, y: 0, z: 0 },
-     *     dimEndPos: { x: 0, y: 100, z: 0 },
-     *     dimTextPos: { x: 10, y: 50, z: 0 },
-     *     dimTextAngle: 0,
-     *     dimOrientation: 'Horizontal',
-     *   },
-     *   dxfView: 'Top',
-     * }
-     *
-     * // Add the dimensions
-     * const dimensionIds = await api.addDimensions(dimension1, dimension2)
-     * @return array containing the ids of added dimensions
-     */
-    addDimensions: (...dimensions: {
-        productId: VID;
-        dimParam: {
-            dimType: 'LinearDimension';
-            dimName?: string;
-            dimLabel: string;
-            dimValue?: number | null;
-            dimStartPos: Vec;
-            dimEndPos: Vec;
-            dimTextPos: Vec;
-            dimTextAngle: number;
-            dimOrientation: OrientationType;
-            dimColor?: number;
-            dimLayer?: string;
-        };
-        dxfView: ViewType;
-    }[]) => Promise<ObjectID[] | null>;
-    /**
-     * Creates different 2D views, depending on the given view types, in the given product.
-     * @param productId id of the product where the view will be created in
-     * @param viewTypes array of view types. E.g. [ViewType.TOP, ViewType.RIGHT_90, ViewType.ISO, ...
-     * @param viewOptions optional object of options (currently color and layer) to set for the views.
-     *  - color: number value 0 - 256, see AutoCAD Color Index (ACI). 256 = color defined by layer
-     *  - layer: string value, defines the view's layer
-     *  - Default = { color: 256, layer: '0'}
-     * @example
-     * // Optionally add dimensions to the product, see addDimension() or addDimensions()
-     * await api.addDimensions(...)
-     *
-     * // 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;
-    /**
-     * This method returns the boundary box of the given views.
-     * @param productId id of the product from where the boundary box will returned
-     * @param viewTypes array of view types. E.g. 'Top', 'Front', 'Iso', ...
-     * @example
-     * // After views have been created, see create2DViews(), you can get boundary boxes
-     * const bbs = await api.getBoundaryBoxFromViews(productId, ['Top', 'Right_90°', 'Iso'])
-     *
-     * // 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][]>;
-    /**
-     * Place the 2D views relatively to the origin.
-     * @param productId id of the product where the views will be placed in
-     * @param viewPositions array of objects, containing the viewType and a vector which defines the moving vector of the given view
-     * @example
-     * // After the views have been created, see create2DViews(), you can place them relatively to origin {0,0,0}
-     * await api.place2DViews(productId, [
-     *   { viewType: 'Iso', vector: { x: 500, y: 500, z: 0 } },
-     *   { viewType: 'Right_90°', vector: { x: 500, y: 0, z: 0 } },
-     * ])
-     */
-    place2DViews: (productId: VID, viewPositions: {
-        viewType: ViewType;
-        vector: Vec;
-    }[]) => Promise<void>;
-    /**
-     * Export the placed views as dxf file.
-     * @param productId id of the product where the views exist for export
-     * @param dxfTemplateFilename optional filename to load different dxf template. E.g. 'StandardTemplate.dxf'
-     * @example
-     * // After creating and placing the views, see place2DViews(), you can export them
-     * // You will get the dxf stream back
-     * await api.exportDXF(productId)
-     */
-    exportDXF: (productId: VID, dxfTemplateFilename?: string) => Promise<Uint8Array | null>;
-    /**
-     * Exports the placed views as dxf and converts it into svg stream.
-     * @param productId id of the product where the views exist for export
-     * @param modus optional modus to define how drawing will fit into svg file,
-     *  - SVGModusType.WHOLE_DRAWING or SVGModusType.FIT_WHOLE_DRAWING
-     *  - Default = SVGModusType.FIT_WHOLE_DRAWING
-     * @param renderSize optional rendered size [x, y] of the drawing.
-     *  - x = horizontal size, y = vertical size
-     *  - Default = 1024 x 768
-     *  - Effects only if modus = SVGModusType.WHOLE_DRAWING
-     * @param dxfTemplateFilename optional filename to load different dxf template. E.g. 'StandardTemplate.dxf'
-     * @example
-     * // After creating and placing the views, see place2DViews(), you can export them
-     * // You will get the svg stream back
-     * await api.exportSVG(productId)
-     */
-    exportSVG: (productId: VID, modus?: SVGModusType, renderSize?: {
-        x: number;
-        y: number;
-    }, dxfTemplateFilename?: string) => Promise<Uint8Array | null>;
-    /**
-     * Remove existing dimensions from the view.
-     * @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 operation
-     * @param partId Id of the part to create the linear pattern in.
-     * @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, operations: VID[], references1: VID[], params1: {
-        inverted: 0 | 1;
-        distance: number | string;
-        count: number | string;
-        merged: 0 | 1;
-    }, references2?: VID[], params2?: {
-        inverted: 0 | 1;
-        distance: number | string;
-        count: number | string;
-    }) => ID;
-    /**
-     * Creates a circular pattern operation
-     * @param partId Id of the part to create the circular pattern in.
-     * @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, operations: VID[], references: VID[], params: {
-        inverted: 0 | 1;
-        angle: number | string;
-        count: number | string;
-        merged: 0 | 1;
-    }) => ID;
-    /**
-     * 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)
-     * @param limit1 Start of extrusion (0 = start at sketch, only for type custom necessary)
-     * @param limit2 End of extrusion, which is actually the height
-     * @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 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 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')
-     * const cyl = api.cylinder(part, [], 10, 100)
-     * const box = api.box(part, [], 20, 20, 20)
-     * 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, operations: VID[]) => ID;
-    /**
-     * 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)
-     * @param width width of the box (y-axis)
-     * @param height height of the box (z-axis)
-     * @example
-     * // Creates a box with a length, width and height of 20
-     * const part = api.createPart('Part')
-     * 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 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)
-     * @param height height of the cylinder (z-axis)
-     * @example
-     * // Creates a cylinder with height = 50 and diameter = 20
-     * const part = api.createPart('Part')
-     * 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 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
-     * @param dist1 1st distance of the chamfer from the edge
-     * @param dist2 2nd distance of the chamfer from the edge. Optional if type = Equal_Distance or Distance_And_Angle
-     * @param angle angle of the chamfer. Optional if type = Equal_Distance or Two_Distances
-     * @example
-     * // Creates a cylinder and puts a chamfer at the bottom edge
-     * const part = api.createPart('Part')
-     * api.cylinder(part, [], 10, 100)
-     * const bottomEdges = await api.pick(part, 'edge', [{ x: 0, y: 0, z: 0 }])
-     * 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 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
-     * @param tDiameter top diameter of the cone
-     * @param height height of the cone
-     * @example
-     * // Creates a cone with bottom diameter = 20, top diameter = 0 and height = 20
-     * const part = api.createPart('Part')
-     * 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 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
-     * @param yOffset defines a offset in y-axis from mate1 to mate2
-     * @param zOffset defines a offset in z-axis from mate1 to mate2
-     * @param name name of the constraint
-     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
-     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
-     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
-     * @example
-     * // Defines some consts
-     * const orig = { x: 0, y: 0, z: 0 }
-     * const xDir = { x: 1, y: 0, z: 0 }
-     * const yDir = { x: 0, y: 1, z: 0 }
-     * const rot = { x: 0, y: 0, z: 0 }
-     * const offset1 = { x: 0, y: 0, z: 0 }
-     * const offset2 = { x: 0, y: 0, z: 0 }
-     * const offset3 = { x: 15, y: 15, z: 30 }
-     *
-     * // Creates the root assembly first
-     * const rootAsm = await api.createRootAssembly('Root_Assembly')
-     *
-     * // Creates a part template and adds geometry to it
-     * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
-     * const wcs3 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset3, rot, false, 'wcs3')
-     * api.box(partTempl1, [wcs1], 30, 30, 30)
-     *
-     * // Creates another part template and adds geometry to it
-     * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
-     * 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 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 instances
-     * await api.createFastenedConstraint(rootAsm, { matePath: [prt1], wcsId: wcs3 }, { matePath: [prt2], wcsId: wcs2 }, 0, 0, 0, 'FC', 0, 0, 0)
-     * const geoms = await api.createBufferGeometry(rootAsm)
-     * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
-     * @return id of the fastened constraint
-     */
-    createFastenedConstraint: (id: VID, mate1: MateParam, mate2: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string, xRotation?: number | string, yRotation?: number | string, zRotation?: number | string) => Promise<ObjectID | null>;
-    /**
-     * Updates multiple fastened constraints
-     * @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
-     * @param yOffset defines a offset in y-axis from mate1 to mate2
-     * @param zOffset defines a offset in z-axis from mate1 to mate2
-     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
-     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
-     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
-     * @example // tbd
-     */
-    updateFastenedConstraints: (...constraints: {
-        constrId: VID;
-        mate1: MateParam;
-        mate2: MateParam;
-        xOffset: number | string;
-        yOffset: number | string;
-        zOffset: number | string;
-        xRotation?: number | string;
-        yRotation?: number | string;
-        zRotation?: number | string;
-    }[]) => Promise<void>;
-    /**
-     * Creates a fastened origin constraint for mate1 to the origin (0, 0, 0).
-     * @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
-     * @param zOffset defines a offset in z-axis from mate1 to mate2
-     * @param name name of the constraint
-     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
-     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
-     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
-     * @example
-     * // Defines some consts
-     * const orig = { x: 0, y: 0, z: 0 }
-     * const xDir = { x: 1, y: 0, z: 0 }
-     * const yDir = { x: 0, y: 1, z: 0 }
-     * const rot = { x: 0, y: 0, z: 0 }
-     * const offset1 = { x: 0, y: 0, z: 0 }
-     * const offset2 = { x: 15, y: 15, z: 15 }
-     *
-     * // Creates the root assembly first
-     * const rootAsm = await api.createRootAssembly('Root_Assembly')
-     *
-     * // Creates a part template and adds geometry to it
-     * const partTempl = await api.createPartAsTemplate('Part_Template')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs')
-     * 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 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, 'FOC', 0, 0, 0)
-     *
-     * 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: (id: VID, mate1: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string, xRotation?: number | string, yRotation?: number | string, zRotation?: number | string) => Promise<ObjectID | null>;
-    /**
-     * Updates multiple fastened origin constraints
-     * @param constraints array of constraint parameter objects. See following 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 xOffset defines a offset in x-axis from mate1 to mate2
-     * @param yOffset defines a offset in y-axis from mate1 to mate2
-     * @param zOffset defines a offset in z-axis from mate1 to mate2
-     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
-     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
-     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
-     * @example // tbd
-     */
-    updateFastenedOriginConstraints: (...constraints: {
-        constrId: VID;
-        mate1: MateParam;
-        xOffset: number | string;
-        yOffset: number | string;
-        zOffset: number | string;
-        xRotation?: number | string;
-        yRotation?: number | string;
-        zRotation?: number | string;
-    }[]) => Promise<void>;
-    /**
-     * Creates a cylindrical constraint between mate1 and mate2 within an assembly.
-     * @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: (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.
-     * @param constrId id of the constraint to update
-     * @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
-     * @example // tbd
-     */
-    updateCylindricalConstraints: (...constraints: {
-        constrId: VID;
-        mate1: MateParam;
-        mate2: MateParam;
-        zOffsetLimits: LimitsParam;
-        zRotationLimits: LimitsParam;
-    }[]) => Promise<void>;
-    /**
-     * Creates a revolute constraint between mate1 and mate2 within an assembly.
-     * @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: (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.
-     * @param constrId id of the constraint to update
-     * @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
-     * @example // tbd
-     */
-    updateRevoluteConstraints: (...constraints: {
-        constrId: VID;
-        mate1: MateParam;
-        mate2: MateParam;
-        zOffset: number | string;
-        zRotationLimits: LimitsParam;
-    }[]) => Promise<void>;
-    /**
-     * Creates a slider constraint between mate1 and mate2 within an assembly.
-     * @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
-     * @param yOffset defines a offset in y-axis from mate1 to mate2
-     * @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: (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.
-     * @param constrId id of the constraint to update
-     * @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
-     * @param yOffset defines a offset in y-axis from mate1 to mate2
-     * @param zOffsetLimits min and max value of offset along z
-     * @example // tbd
-     */
-    updateSliderConstraints: (...constraints: {
-        constrId: VID;
-        mate1: MateParam;
-        mate2: MateParam;
-        xOffset: number | string;
-        yOffset: number | string;
-        zOffsetLimits: LimitsParam;
-    }[]) => Promise<void>;
-    /**
-     * Creates a planar constraint between mate1 and mate2 within an assembly.
-     * @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 xOffsetLimits min and max value of offset along x
-     * @param yOffsetLimits min and max value of offset along y
-     * @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: (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.
-     * @param constrId id of the constraint to update
-     * @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 xOffsetLimits min and max value of offset along x
-     * @param yOffsetLimits min and max value of offset along y
-     * @param zRotationLimits min and max value of rotation around z
-     * @example // tbd
-     */
-    updatePlanarConstraints: (...constraints: {
-        constrId: VID;
-        mate1: MateParam;
-        mate2: MateParam;
-        zOffset: number | string;
-        xOffsetLimits: LimitsParam;
-        yOffsetLimits: LimitsParam;
-        zRotationLimits: LimitsParam;
-    }[]) => Promise<void>;
-    /**
-     * Creates a parallel constraint between mate1 and mate2 within an assembly.
-     * @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
-     * @param yOffsetLimits min and max value of offset along y
-     * @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 parallel constraint
-     */
-    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.
-     * @param constrId id of the constraint to update
-     * @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
-     * @param yOffsetLimits min and max value of offset along y
-     * @param zOffsetLimits min and max value of offset along z
-     * @param zRotationLimits min and max value of rotation around z
-     * @example // tbd
-     */
-    updateParallelConstraints: (...constraints: {
-        constrId: VID;
-        mate1: MateParam;
-        mate2: MateParam;
-        xOffsetLimits: LimitsParam;
-        yOffsetLimits: LimitsParam;
-        zOffsetLimits: LimitsParam;
-        zRotationLimits: LimitsParam;
-    }[]) => 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;
-        paramName: LimitedValue;
-        value: number;
-    }[]) => Promise<void>;
-    /**
-     * 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
-     * const part = api.createPart('Part')
-     * 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 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 and materials
-     * @example // tbd
-     */
-    createScene: (productId?: VID, options?: {
-        meshPerGeometry?: boolean;
-        structureOnly?: boolean;
-    }) => Promise<{
-        scene: Scene;
-        nodes: {
-            [key: string]: Object3D;
-        };
-        materials: {
-            [key: string]: Material;
-        };
-    }>;
-    /**
-     * Creates one or more expressions.
-     * @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
-     * const part = api.createPart('Part')
-     * api.createExpressions(part, { name: 'width', value: 20 })
-     * 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 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
-     * const orig = { x: 0, y: 0, z: 0 }
-     * const xDir = { x: 1, y: 0, z: 0 }
-     * const yDir = { x: 0, y: 1, z: 0 }
-     * const rot = { x: 0, y: 0, z: 0 }
-     * const offset1 = { x: 0, y: 0, z: 0 }
-     * const offset2 = { x: 0, y: 0, z: 0 }
-     * const offset3 = { x: 50, y: 0, z: 0 }
-     *
-     * // Creates the root assembly first
-     * const rootAsm = await api.createRootAssembly('Root_Assembly')
-     *
-     * // Creates a assembly template
-     * const asmTempl = await api.createAssemblyAsTemplate('Assembly_Template')
-     *
-     * // Creates a part template and adds geometry to it
-     * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
-     * api.box(partTempl1, [wcs1], 30, 30, 30)
-     *
-     * // Creates another part template and adds geometry to it
-     * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
-     * 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 instances to the assembly
-     * // and the assembly itself multiple times to the root assembly
-     * 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 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 an identifier for the created root assembly
-     * @example
-     * // Defines some consts
-     * const orig = { x: 0, y: 0, z: 0 }
-     * const xDir = { x: 1, y: 0, z: 0 }
-     * const yDir = { x: 0, y: 1, z: 0 }
-     * const rot = { x: 0, y: 0, z: 0 }
-     * const offset = { x: 20, y: 0, z: 0 }
-     *
-     * // Creates the root assembly first
-     * const rootAsm = await api.createRootAssembly('Root_Assembly')
-     *
-     * // Creates a part template and adds geometry to it
-     * const partTempl = await api.createPartAsTemplate('Part_Template')
-     * 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 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 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
-     * const part = api.createPart('Part')
-     * 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 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
-     * const orig = { x: 0, y: 0, z: 0 }
-     * const xDir = { x: 1, y: 0, z: 0 }
-     * const yDir = { x: 0, y: 1, z: 0 }
-     * const rot = { x: 0, y: 0, z: 0 }
-     * const offset = { x: 20, y: 0, z: 0 }
-     *
-     * // Creates the root assembly first
-     * const rootAsm = await api.createRootAssembly('Root_Assembly')
-     *
-     * // Creates a part template and adds geometry to it
-     * const partTempl = await api.createPartAsTemplate('Part_Template')
-     * 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 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;
-    /**
-     * Creates a new work axis for the given part
-     * @param partId id of the part to add the new work axis to
-     * @param type type of the work axis
-     * @param references references for the work axis, needed for all types except 'Custom'
-     * @param position position of axis, only needed if type = 'Custom'
-     * @param direction direction of axis, only needed if type = 'Custom'
-     * @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;
-    /**
-     * Creates a new work coordinate system for the given part.
-     * @param partId id of the part to add the new work coord system to
-     * @param type type of the work coordinate system
-     * @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 direction of the primary axis
-     * @param name name of the work coordinate system, if not set default name = 'WorkCoordSystem'
-     * @example
-     * // Defines some consts
-     * const orig = { x: 0, y: 0, z: 0 }
-     * const xDir = { x: 1, y: 0, z: 0 }
-     * const yDir = { x: 0, y: 1, z: 0 }
-     * const rot = { x: 0, y: 0, z: 0 }
-     * const offset1 = { x: 0, y: 0, z: 0 }
-     * const offset2 = { x: 0, y: 0, z: 0 }
-     * const offset3 = { x: 15, y: 15, z: 30 }
-     *
-     * // Creates the root assembly first
-     * const rootAsm = await api.createRootAssembly('Root_Assembly')
-     *
-     * // Creates a part template and adds geometry to it
-     * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
-     * const wcs3 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset3, rot, false, 'wcs3')
-     * api.box(partTempl1, [wcs1], 30, 30, 30)
-     *
-     * // Creates another part template and adds geometry to it
-     * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
-     * 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 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 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;
-    /**
-     * Creates a new work plane for the given part
-     * @param partId id of the part to add the new work plane to
-     * @param type type of the work plane
-     * @param references references for the work plane, needed for all types except 'Custom'
-     * @param offset offset in normal direction, can be used for all types except 'LinePlaneAndAngle'
-     * @param angle angle in degrees, needed for type 'LinePlaneAndAngle'
-     * @param position position of plane, only needed if type = 'Custom'
-     * @param normal normal vector of work plane, only needed if type = 'Custom'
-     * @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;
-    /**
-     * Creates a new work point for the given part
-     * @param partId id of the part to add the new work point to
-     * @param type type of the work point
-     * @param references references for the work point, needed for all types except 'Custom'
-     * @param position position of point, only needed if type = 'Custom'
-     * @param direction direction of point, only needed if type = 'Custom'
-     * @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 existing expressions.
-     * @param partId id or identifier of part to delete expressions from
-     * @param members name of members to delete
-     * @example
-     * // Deletes an expression from part's expression set
-     * const part = api.createPart('Part')
-     * api.createExpressions(part, { name: 'width', value: 20 }, { name: 'height', value: 40 })
-     * api.deleteExpressions(part, ['height'])
-     * 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>;
-    /**
-     * Loads a sketch from a ofb filestream and adds its elements to a new sketch.
-     * The id of this new created sketch will be returned.
-     *
-     * @param partId id of the part we want to create the new sketch and copy the sketch elements into it
-     * @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;
-    /**
-     * Copy an existing sketch and adds its elements to a new sketch.
-     * The id of this new created sketch will be returned.
-     *
-     * @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;
-    /**
-     * Place/position the sketch with plane, axis and origin references.
-     *
-     * @param sketchId id of the sketch to place
-     * @param planeId - id of a face or a workplane. This will be the plane where the sketch lies on.
-     * If a plane reference already exists, planeId is optional
-     * @param invertPlane - if true, the normal of the plane will be inverted
-     * @param axisId - optional id of an edge or workaxis. This will be the x-Axis
-     * @param isXAxis - if true, the axisId will be the x-axis of the sketch, else the x-Axis will be the crossvector of the normal and the axisId
-     * @param invertAxis - if true, the direction of the axis will be inverted
-     * @param originId - optional point or vertex of the sketch's origin reference
-     */
-    placeSketch: (sketchId: VID, planeId: VID, invertPlane: boolean, axisId: VID, isXAxis: boolean, invertAxis: boolean, originId: VID) => Promise<void>;
-    /**
-     * 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
-     * // Creates a sphere with radius = 20
-     * const part = api.createPart('Part')
-     * 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 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
-     * @example
-     * // Creates a cylinder and puts a fillet at the top edge
-     * const part = api.createPart('Part')
-     * api.cylinder(part, [], 10, 100)
-     * const topEdges = await api.pick(part, 'edge', [{ x: 0, y: 0, z: 100 }])
-     * 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 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 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: <T = GeometryElement>(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.
-     * @param type Type of the geometry to look for
-     * @param positions Array of elements containing one or more positions to look for the geometry
-     * @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 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
-     */
-    getAssemblyTemplate: (asmName?: string) => IDs;
-    /**
-     * 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
-     */
-    getInstance: (id: VID, instanceName?: string) => IDs;
-    /**
-     * Find first instance which can be identified by given identifier or name.
-     * If both optional parameters has been set, the identifier is treated with priority.
-     * If no instance with given identifier will be found, the name is used to find an instance.
-     *
-     * @param drawingId The drawing id.
-     * @param options Optional parameters to identify to find instance.
-     * @param options.instanceIdent Identifier to find the instance by an identifier
-     * @param options.instanceName Name to find the instance by its name
-     * @returns first found instance which meets the searching conditions or null if nothing could be found
-     */
-    findInstance: (options: {
-        instanceIdent?: ObjectIdent;
-        instanceName?: string;
-    }) => ID;
-    /**
-     * 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
-     */
-    getProductsOfInstances: (instanceIds: VID[]) => IDs;
-    /**
-     * Returns the id of the current product
-     * @example // tbd
-     */
-    getCurrentProduct: () => ID;
-    /**
-     * Sets the instance with id to the new current instance
-     *
-     * @param id id of the instance to set as the current
-     * @example // tbd
-     */
-    setCurrentInstance: (id: VID) => Promise<void>;
-    /**
-     * Sets the product with productId to the new current product
-     *
-     * @param productId Id of the product to set as the current
-     * @example // tbd
-     */
-    setCurrentProduct: (productId: VID) => Promise<void>;
-    /**
-     * Returns the id of the current instance
-     * @example // tbd
-     * @return id of the current instance
-     */
-    getCurrentInstance: () => ID;
-    /**
-     * Returns the global transformation of the given id.
-     * Currently only ids of instances supported.
-     *
-     * @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]
-     * ]
-     */
-    getTransformation: (id: VID) => Promise<number[][]>;
-    /**
-     * 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
-     */
-    getPartTemplate: (partName?: string) => IDs;
-    /**
-     * 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
-     * // Adds a loaded part to an assembly. To set the part to the origin of the
-     * // assembly with a constraint, the work coord system can be get from part by name.
-     * const pt0 = { x: 0, y: 0, z: 0 }
-     * const xDir = { x: 1, y: 0, z: 0 }
-     * 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.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: (id: VID, wcsName?: string) => IDs;
-    /**
-     * 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
-     * @example // tbd
-     * @return array containing ids of the sketch regions
-     */
-    getSketchRegion: (id: VID, sketchRegionName?: 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
-     * @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: (id: VID, type: WorkGeomType, wgName?: string) => IDs;
-    /**
-     * 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
-     * @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 ],
-     *    [ reference id of second mate, workcoordsystem id of second mate, flip type of second mate, reoriented type of second mate ],
-     *    xOffset,
-     *    yOffset,
-     *    zOffset
-     * ]
-     */
-    getConstraint: (refId: VID, constrName?: string) => Promise<ConstraintType>;
-    /**
-     * 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
-     * @return found fastened constraint as object.
-     */
-    getFastenedConstraint: (id: VID, constrName: string) => Promise<FastenedConstraintType>;
-    /**
-     * 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
-     * @return found fastened origin constraint as object.
-     */
-    getFastenedOriginConstraint: (id: VID, constrName: string) => Promise<FastenedOriginConstraintType>;
-    /**
-     * 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
-     * @return found revolute constraint as object.
-     */
-    getRevoluteConstraint: (id: VID, constrName: string) => Promise<RevoluteConstraintType>;
-    /**
-     * 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
-     * @return found slider constraint as object.
-     */
-    getSliderConstraint: (id: VID, constrName: string) => Promise<SliderConstraintType>;
-    /**
-     * 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
-     * @return found planar constraint as object.
-     */
-    getPlanarConstraint: (id: VID, constrName: string) => Promise<PlanarConstraintType>;
-    /**
-     * 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
-     * @return found parallel constraint as object.
-     */
-    getParallelConstraint: (id: VID, constrName: string) => Promise<ParallelConstraintType>;
-    /**
-     * 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
-     * @return found cylindrical constraint as object.
-     */
-    getCylindricalConstraint: (id: VID, constrName: string) => Promise<CylindricalConstraintType>;
-    /**
-     * 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 / 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, 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 id id of the part, assembly, instance or solid we want the information from
-     * @example // tbd
-     * @return object containing the geometry information
-     */
-    getGeometryInformation: (id: VID) => Promise<ModelInfo | null>;
-    /**
-     * Writes the current drawing to a stream and returns the data.
-     *
-     * Important notes about the ofb format:
-     *    - It contains binary geometry blocks.
-     *    - Do not try to convert it to text, the geometry blocks will get damaged!
-     *
-     * @param type type to write
-     * @example // tbd
-     * @return stream data
-     */
-    save: (type: 'ofb' | 'stp') => Promise<Uint8Array | null>;
-    /**
-     * 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', 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', options?: {
-        ident?: ObjectIdent;
-    }) => Promise<number[] | null>;
-    /**
-     * 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 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 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 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 instances from root assembly, other instances or assembly templates.
-     * @param instances array of instance objects. See following parameter descriptions.
-     * @param id id, identifier or name of the instance to remove
-     * @example // tbd
-     */
-    removeInstances: (...instances: {
-        id: VID | ObjectIdent;
-    }[]) => Promise<void>;
-    /**
-     * 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, identifier or name of the instance to transform
-     * @param transformation transformation (origin, xDir, yDir) of the instance local to the owner.
-     * @example // tbd
-     */
-    transformInstances: (...instances: {
-        id: VID | ObjectIdent;
-        transformation: Transform;
-    }[]) => Promise<void>;
-    /**
-     * Creates a translate operation
-     * @param partId id ot the part where features 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, operations: VID[], references: VID[], inverted: 0 | 1, distance: number | string) => ID;
-    /**
-     * 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>;
-    /**
-     * Returns found vertices, edges or faces depending on
-     * 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
-     * @example
-     * // Creates a cylinder an puts a fillet on the top edge
-     * const part = api.createPart('Part')
-     * api.cylinder(part, [], 10, 100)
-     * const edges = await api.pick(part, 'edge', [{ x: 0, y: 0, z: 100 }])
-     * 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, identifier or name 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'
-     * @example // tbd
-     * @returns true, if updating expressions in all parts was successfull
-     */
-    setExpressions: (...expressions: {
-        partId: VID | ObjectIdent;
-        members: {
-            name: string;
-            value: number | string;
-        }[];
-    }[]) => Promise<boolean>;
-    /**
-     * 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 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, 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 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 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: (instanceId: VID | ObjectIdent) => 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 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 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 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;
-};
-export default class CAD {
-    drawingId: DrawingID | null;
-    queue: Promise<number>;
-    constructor();
-    resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
-    init(callback: (api: ApiHistory) => void): () => Promise<void>;
-    destroy(): void;
-}
-declare type VID = ObjectID | null | Promise<ObjectID | null>;
-declare type VIDs = ObjectID[] | Promise<ObjectID[]>;
-declare type ID = Promise<ObjectID | null>;
-declare type IDs = Promise<ObjectID[]>;
-declare type Point = {
-    x: number;
-    y: number;
-    z: number;
-};
-declare type ModelInfo = {
-    centerOfGravity: Vec;
-    volume: number;
-};
-declare type MateParam = {
-    matePath: VID[];
-    wcsId: VID;
-    flip: FlipType;
-    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;
-    /** rotation around x-axis */
-    xRotation?: number | string;
-    /** rotation around y-axis */
-    yRotation?: number | string;
-    /** rotation around z-axis */
-    zRotation?: 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;
-    /** rotation around x-axis */
-    xRotation?: number | string;
-    /** rotation around y-axis */
-    yRotation?: number | string;
-    /** rotation around z-axis */
-    zRotation?: 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 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
- * ]
- */
-export declare type ConstraintType = [
-    number,
-    [
-        number[],
-        number,
-        number,
-        number
-    ],
-    [
-        number[],
-        number,
-        number,
-        number
-    ],
-    number,
-    number,
-    number,
-    number,
-    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 {};
+import { BooleanOperationType, ChamferType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, ExtrusionType, WorkGeomType, SVGModusType, LimitsParam, DimensionParam, LimitedValue } from '@buerli.io/classcad';
+import { DrawingID, ObjectIdent, ObjectID, GraphicType, InteractionInfo, GeometryElement, DrawingState, BuerliState } from '@buerli.io/core';
+import { BufferGeometry, Material, Object3D, Scene } from 'three';
+/**
+ * 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
+ * expressions which you can alter at a later time, prompting your model to re-calculate.
+ * Use this for assembly and variant configurators.
+ *
+ * > The history modeling approach relies heavily on the underlying `assemblyBuilder ClassCAD API`.
+ * Since this part of the API is still under construction, the interfaces of the history functions
+ * can still change.
+ *
+ * ```sh
+ * npm install @buerli.io/headless
+ * ```
+ *
+ * ```js
+ * import { History } from '@buerli.io/headless'
+ * const cad = new History(url)
+ * cad.init(async api => {
+ *     // Your code goes here
+ * })
+ * ```
+ */
+export declare type ApiHistory = {
+    /**
+     * Returns the drawing id of the current headless-session
+     * @returns DrawingID
+     * @example
+     * const drawingId = api.getDrawingId()
+     */
+    getDrawingId: () => DrawingID;
+    /**
+     * Returns the drawing of the current headless-session
+     * @returns DrawingState
+     * @example
+     * const drawing = api.getDrawing()
+     * // Get all graphic containers
+     * const containers = Object.values(drawing.graphic.containers)
+     * containers.forEach(container => {
+     * // Get all surfaces
+     * const surfaces = container.meshes.map(mesh => mesh.properties.surface)
+     * // Filter non cylindric
+     * const cylinders = surfaces.filter(surface => surface.type === 'cylinder')
+     * // Check if all cylinders have a radius greater than 4
+     * cylinders.forEach(meta => expect(meta.radius).toBeGreaterThanOrEqual(4))
+     * })
+     */
+    getDrawing: () => DrawingState;
+    /**
+     * Returns the state tree of the current headless-session
+     * @returns BuerliState
+     * @example
+     * const state = api.getState()
+     */
+    getState: () => BuerliState;
+    /**
+     * Sets the global faceting parameters that will stick for this drawing.
+     * This defines how detailed solids will be displayed and can yield smaller payloads.
+     * @param distanceTol distance tolerance
+     * @param angleTol angle tolerance
+     * @returns void
+     * @example
+     * api.setFacetingParameters(0.1, 0)
+     */
+    setFacetingParameters: (distanceTol: number, angleTol: number) => Promise<void>;
+    /**
+     * 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, identifier or name of the product to instantiate
+     * @param ownerId id, identifier or name 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
+     */
+    addInstances: (...instances: {
+        productId: VID | ObjectIdent;
+        ownerId: VID | ObjectIdent;
+        transformation: Transform;
+        name?: string;
+        options?: {
+            ident?: ObjectIdent;
+        };
+    }[]) => Promise<ObjectID[] | null>;
+    /**
+     * Adds multiple dimensions to products in the 3D view
+     * @param dimensions dimensions to be added to products
+     * @example
+     * // Get the current product
+     * const productId = await api.getCurrentProduct()
+     *
+     * // Create dimensions
+     * const dimension1: DimensionType = {
+     *   productId: productId,
+     *   dimParam: {
+     *     dimType: 'LinearDimension',
+     *     dimLabel: 'Breite = ',
+     *     dimStartPos: { x: 0, y: 0, z: 0 },
+     *     dimEndPos: { x: 100, y: 0, z: 0 },
+     *     dimTextPos: { x: 50, y: -10, z: 0 },
+     *     dimTextAngle: 0,
+     *     dimOrientation: 'Horizontal',
+     *   },
+     *   dxfView: 'Top',
+     * }
+     *
+     * const dimension2: DimensionType = {
+     *   productId: productId,
+     *   dimParam: {
+     *     dimType: 'LinearDimension',
+     *     dimLabel: 'Laenge = ',
+     *     dimStartPos: { x: 0, y: 0, z: 0 },
+     *     dimEndPos: { x: 0, y: 100, z: 0 },
+     *     dimTextPos: { x: 10, y: 50, z: 0 },
+     *     dimTextAngle: 0,
+     *     dimOrientation: 'Horizontal',
+     *   },
+     *   dxfView: 'Top',
+     * }
+     *
+     * // Add the dimensions
+     * const dimensionIds = await api.addDimensions(dimension1, dimension2)
+     * @return array containing the ids of added dimensions
+     */
+    addDimensions: (...dimensions: DimensionType[]) => Promise<ObjectID[] | null>;
+    /**
+     * Creates different 2D views, depending on the given view types, in the given product.
+     * @param productId id of the product where the view will be created in
+     * @param viewTypes array of view types. E.g. [ViewType.TOP, ViewType.RIGHT_90, ViewType.ISO, ...
+     * @param viewOptions optional object of options (currently color and layer) to set for the views.
+     *  - color: number value 0 - 256, see AutoCAD Color Index (ACI). 256 = color defined by layer
+     *  - layer: string value, defines the view's layer
+     *  - Default = { color: 256, layer: '0'}
+     * @example
+     * // Optionally add dimensions to the product, see addDimension() or addDimensions()
+     * await api.addDimensions(...)
+     *
+     * // 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;
+    /**
+     * This method returns the boundary box of the given views.
+     * @param productId id of the product from where the boundary box will returned
+     * @param viewTypes array of view types. E.g. 'Top', 'Front', 'Iso', ...
+     * @example
+     * // After views have been created, see create2DViews(), you can get boundary boxes
+     * const bbs = await api.getBoundaryBoxFromViews(productId, ['Top', 'Right_90°', 'Iso'])
+     *
+     * // 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][]>;
+    /**
+     * Place the 2D views relatively to the origin.
+     * @param productId id of the product where the views will be placed in
+     * @param viewPositions array of objects, containing the viewType and a vector which defines the moving vector of the given view
+     * @example
+     * // After the views have been created, see create2DViews(), you can place them relatively to origin {0,0,0}
+     * await api.place2DViews(productId, [
+     *   { viewType: 'Iso', vector: { x: 500, y: 500, z: 0 } },
+     *   { viewType: 'Right_90°', vector: { x: 500, y: 0, z: 0 } },
+     * ])
+     */
+    place2DViews: (productId: VID, viewPositions: {
+        viewType: ViewType;
+        vector: Vec;
+    }[]) => Promise<void>;
+    /**
+     * Export the placed views as dxf file.
+     * @param productId id of the product where the views exist for export
+     * @param dxfTemplateFilename optional filename to load different dxf template. E.g. 'StandardTemplate.dxf'
+     * @example
+     * // After creating and placing the views, see place2DViews(), you can export them
+     * // You will get the dxf stream back
+     * await api.exportDXF(productId)
+     */
+    exportDXF: (productId: VID, dxfTemplateFilename?: string) => Promise<Uint8Array | null>;
+    /**
+     * Exports the placed views as dxf and converts it into svg stream.
+     * @param productId id of the product where the views exist for export
+     * @param modus optional modus to define how drawing will fit into svg file,
+     *  - SVGModusType.WHOLE_DRAWING or SVGModusType.FIT_WHOLE_DRAWING
+     *  - Default = SVGModusType.FIT_WHOLE_DRAWING
+     * @param renderSize optional rendered size [x, y] of the drawing.
+     *  - x = horizontal size, y = vertical size
+     *  - Default = 1024 x 768
+     *  - Effects only if modus = SVGModusType.WHOLE_DRAWING
+     * @param dxfTemplateFilename optional filename to load different dxf template. E.g. 'StandardTemplate.dxf'
+     * @example
+     * // After creating and placing the views, see place2DViews(), you can export them
+     * // You will get the svg stream back
+     * await api.exportSVG(productId)
+     */
+    exportSVG: (productId: VID, modus?: SVGModusType, renderSize?: {
+        x: number;
+        y: number;
+    }, dxfTemplateFilename?: string) => Promise<Uint8Array | null>;
+    /**
+     * Remove existing dimensions from the view.
+     * @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 operation
+     * @param partId Id of the part to create the linear pattern in.
+     * @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, operations: VID[], references1: VID[], params1: {
+        inverted: 0 | 1;
+        distance: number | string;
+        count: number | string;
+        merged: 0 | 1;
+    }, references2?: VID[], params2?: {
+        inverted: 0 | 1;
+        distance: number | string;
+        count: number | string;
+    }) => ID;
+    /**
+     * Creates a circular pattern operation
+     * @param partId Id of the part to create the circular pattern in.
+     * @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, operations: VID[], references: VID[], params: {
+        inverted: 0 | 1;
+        angle: number | string;
+        count: number | string;
+        merged: 0 | 1;
+    }) => ID;
+    /**
+     * 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)
+     * @param limit1 Start of extrusion (0 = start at sketch, only for type custom necessary)
+     * @param limit2 End of extrusion, which is actually the height
+     * @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<number | string>, capEnds: 0 | 1) => ID;
+    /**
+     * 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 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')
+     * const cyl = api.cylinder(part, [], 10, 100)
+     * const box = api.box(part, [], 20, 20, 20)
+     * 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, operations: VID[]) => ID;
+    /**
+     * 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)
+     * @param width width of the box (y-axis)
+     * @param height height of the box (z-axis)
+     * @example
+     * // Creates a box with a length, width and height of 20
+     * const part = api.createPart('Part')
+     * 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 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)
+     * @param height height of the cylinder (z-axis)
+     * @example
+     * // Creates a cylinder with height = 50 and diameter = 20
+     * const part = api.createPart('Part')
+     * 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 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
+     * @param dist1 1st distance of the chamfer from the edge
+     * @param dist2 2nd distance of the chamfer from the edge. Optional if type = Equal_Distance or Distance_And_Angle
+     * @param angle angle of the chamfer. Optional if type = Equal_Distance or Two_Distances
+     * @example
+     * // Creates a cylinder and puts a chamfer at the bottom edge
+     * const part = api.createPart('Part')
+     * api.cylinder(part, [], 10, 100)
+     * const bottomEdges = await api.pick(part, 'edge', [{ x: 0, y: 0, z: 0 }])
+     * 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 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
+     * @param tDiameter top diameter of the cone
+     * @param height height of the cone
+     * @example
+     * // Creates a cone with bottom diameter = 20, top diameter = 0 and height = 20
+     * const part = api.createPart('Part')
+     * 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 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
+     * @param yOffset defines a offset in y-axis from mate1 to mate2
+     * @param zOffset defines a offset in z-axis from mate1 to mate2
+     * @param name name of the constraint
+     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
+     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
+     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
+     * @example
+     * // Defines some consts
+     * const orig = { x: 0, y: 0, z: 0 }
+     * const xDir = { x: 1, y: 0, z: 0 }
+     * const yDir = { x: 0, y: 1, z: 0 }
+     * const rot = { x: 0, y: 0, z: 0 }
+     * const offset1 = { x: 0, y: 0, z: 0 }
+     * const offset2 = { x: 0, y: 0, z: 0 }
+     * const offset3 = { x: 15, y: 15, z: 30 }
+     *
+     * // Creates the root assembly first
+     * const rootAsm = await api.createRootAssembly('Root_Assembly')
+     *
+     * // Creates a part template and adds geometry to it
+     * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
+     * const wcs3 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset3, rot, false, 'wcs3')
+     * api.box(partTempl1, [wcs1], 30, 30, 30)
+     *
+     * // Creates another part template and adds geometry to it
+     * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
+     * 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 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 instances
+     * await api.createFastenedConstraint(rootAsm, { matePath: [prt1], wcsId: wcs3 }, { matePath: [prt2], wcsId: wcs2 }, 0, 0, 0, 'FC', 0, 0, 0)
+     * const geoms = await api.createBufferGeometry(rootAsm)
+     * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the fastened constraint
+     */
+    createFastenedConstraint: (id: VID, mate1: MateParam, mate2: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string, xRotation?: number | string, yRotation?: number | string, zRotation?: number | string) => Promise<ObjectID | null>;
+    /**
+     * Updates multiple fastened constraints
+     * @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
+     * @param yOffset defines a offset in y-axis from mate1 to mate2
+     * @param zOffset defines a offset in z-axis from mate1 to mate2
+     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
+     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
+     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
+     * @example // tbd
+     */
+    updateFastenedConstraints: (...constraints: {
+        constrId: VID;
+        mate1: MateParam;
+        mate2: MateParam;
+        xOffset: number | string;
+        yOffset: number | string;
+        zOffset: number | string;
+        xRotation?: number | string;
+        yRotation?: number | string;
+        zRotation?: number | string;
+    }[]) => Promise<void>;
+    /**
+     * Creates a fastened origin constraint for mate1 to the origin (0, 0, 0).
+     * @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
+     * @param zOffset defines a offset in z-axis from mate1 to mate2
+     * @param name name of the constraint
+     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
+     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
+     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
+     * @example
+     * // Defines some consts
+     * const orig = { x: 0, y: 0, z: 0 }
+     * const xDir = { x: 1, y: 0, z: 0 }
+     * const yDir = { x: 0, y: 1, z: 0 }
+     * const rot = { x: 0, y: 0, z: 0 }
+     * const offset1 = { x: 0, y: 0, z: 0 }
+     * const offset2 = { x: 15, y: 15, z: 15 }
+     *
+     * // Creates the root assembly first
+     * const rootAsm = await api.createRootAssembly('Root_Assembly')
+     *
+     * // Creates a part template and adds geometry to it
+     * const partTempl = await api.createPartAsTemplate('Part_Template')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs')
+     * 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 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, 'FOC', 0, 0, 0)
+     *
+     * 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: (id: VID, mate1: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string, xRotation?: number | string, yRotation?: number | string, zRotation?: number | string) => Promise<ObjectID | null>;
+    /**
+     * Updates multiple fastened origin constraints
+     * @param constraints array of constraint parameter objects. See following 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 xOffset defines a offset in x-axis from mate1 to mate2
+     * @param yOffset defines a offset in y-axis from mate1 to mate2
+     * @param zOffset defines a offset in z-axis from mate1 to mate2
+     * @param xRotation [optional] defines a rotation of mate2 around x-axis of mate1
+     * @param yRotation [optional] defines a rotation of mate2 around y-axis of mate1
+     * @param zRotation [optional] defines a rotation of mate2 around z-axis of mate1
+     * @example // tbd
+     */
+    updateFastenedOriginConstraints: (...constraints: {
+        constrId: VID;
+        mate1: MateParam;
+        xOffset: number | string;
+        yOffset: number | string;
+        zOffset: number | string;
+        xRotation?: number | string;
+        yRotation?: number | string;
+        zRotation?: number | string;
+    }[]) => Promise<void>;
+    /**
+     * Creates a cylindrical constraint between mate1 and mate2 within an assembly.
+     * @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: (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.
+     * @param constrId id of the constraint to update
+     * @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
+     * @example // tbd
+     */
+    updateCylindricalConstraints: (...constraints: {
+        constrId: VID;
+        mate1: MateParam;
+        mate2: MateParam;
+        zOffsetLimits: LimitsParam;
+        zRotationLimits: LimitsParam;
+    }[]) => Promise<void>;
+    /**
+     * Creates a revolute constraint between mate1 and mate2 within an assembly.
+     * @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: (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.
+     * @param constrId id of the constraint to update
+     * @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
+     * @example // tbd
+     */
+    updateRevoluteConstraints: (...constraints: {
+        constrId: VID;
+        mate1: MateParam;
+        mate2: MateParam;
+        zOffset: number | string;
+        zRotationLimits: LimitsParam;
+    }[]) => Promise<void>;
+    /**
+     * Creates a slider constraint between mate1 and mate2 within an assembly.
+     * @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
+     * @param yOffset defines a offset in y-axis from mate1 to mate2
+     * @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: (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.
+     * @param constrId id of the constraint to update
+     * @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
+     * @param yOffset defines a offset in y-axis from mate1 to mate2
+     * @param zOffsetLimits min and max value of offset along z
+     * @example // tbd
+     */
+    updateSliderConstraints: (...constraints: {
+        constrId: VID;
+        mate1: MateParam;
+        mate2: MateParam;
+        xOffset: number | string;
+        yOffset: number | string;
+        zOffsetLimits: LimitsParam;
+    }[]) => Promise<void>;
+    /**
+     * Creates a planar constraint between mate1 and mate2 within an assembly.
+     * @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 xOffsetLimits min and max value of offset along x
+     * @param yOffsetLimits min and max value of offset along y
+     * @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: (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.
+     * @param constrId id of the constraint to update
+     * @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 xOffsetLimits min and max value of offset along x
+     * @param yOffsetLimits min and max value of offset along y
+     * @param zRotationLimits min and max value of rotation around z
+     * @example // tbd
+     */
+    updatePlanarConstraints: (...constraints: {
+        constrId: VID;
+        mate1: MateParam;
+        mate2: MateParam;
+        zOffset: number | string;
+        xOffsetLimits: LimitsParam;
+        yOffsetLimits: LimitsParam;
+        zRotationLimits: LimitsParam;
+    }[]) => Promise<void>;
+    /**
+     * Creates a parallel constraint between mate1 and mate2 within an assembly.
+     * @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
+     * @param yOffsetLimits min and max value of offset along y
+     * @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 parallel constraint
+     */
+    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.
+     * @param constrId id of the constraint to update
+     * @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
+     * @param yOffsetLimits min and max value of offset along y
+     * @param zOffsetLimits min and max value of offset along z
+     * @param zRotationLimits min and max value of rotation around z
+     * @example // tbd
+     */
+    updateParallelConstraints: (...constraints: {
+        constrId: VID;
+        mate1: MateParam;
+        mate2: MateParam;
+        xOffsetLimits: LimitsParam;
+        yOffsetLimits: LimitsParam;
+        zOffsetLimits: LimitsParam;
+        zRotationLimits: LimitsParam;
+    }[]) => 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;
+        paramName: LimitedValue;
+        value: number;
+    }[]) => Promise<void>;
+    /**
+     * 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
+     * const part = api.createPart('Part')
+     * 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 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 and materials
+     * @example // tbd
+     */
+    createScene: (productId?: VID, options?: {
+        meshPerGeometry?: boolean;
+        structureOnly?: boolean;
+    }) => Promise<{
+        scene: Scene;
+        nodes: {
+            [key: string]: Object3D;
+        };
+        materials: {
+            [key: string]: Material;
+        };
+    }>;
+    /**
+     * Creates one or more expressions.
+     * @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
+     * const part = api.createPart('Part')
+     * api.createExpressions(part, { name: 'width', value: 20 })
+     * 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 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
+     * const orig = { x: 0, y: 0, z: 0 }
+     * const xDir = { x: 1, y: 0, z: 0 }
+     * const yDir = { x: 0, y: 1, z: 0 }
+     * const rot = { x: 0, y: 0, z: 0 }
+     * const offset1 = { x: 0, y: 0, z: 0 }
+     * const offset2 = { x: 0, y: 0, z: 0 }
+     * const offset3 = { x: 50, y: 0, z: 0 }
+     *
+     * // Creates the root assembly first
+     * const rootAsm = await api.createRootAssembly('Root_Assembly')
+     *
+     * // Creates a assembly template
+     * const asmTempl = await api.createAssemblyAsTemplate('Assembly_Template')
+     *
+     * // Creates a part template and adds geometry to it
+     * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
+     * api.box(partTempl1, [wcs1], 30, 30, 30)
+     *
+     * // Creates another part template and adds geometry to it
+     * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
+     * 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 instances to the assembly
+     * // and the assembly itself multiple times to the root assembly
+     * 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 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 an identifier for the created root assembly
+     * @example
+     * // Defines some consts
+     * const orig = { x: 0, y: 0, z: 0 }
+     * const xDir = { x: 1, y: 0, z: 0 }
+     * const yDir = { x: 0, y: 1, z: 0 }
+     * const rot = { x: 0, y: 0, z: 0 }
+     * const offset = { x: 20, y: 0, z: 0 }
+     *
+     * // Creates the root assembly first
+     * const rootAsm = await api.createRootAssembly('Root_Assembly')
+     *
+     * // Creates a part template and adds geometry to it
+     * const partTempl = await api.createPartAsTemplate('Part_Template')
+     * 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 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 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
+     * const part = api.createPart('Part')
+     * 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 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
+     * const orig = { x: 0, y: 0, z: 0 }
+     * const xDir = { x: 1, y: 0, z: 0 }
+     * const yDir = { x: 0, y: 1, z: 0 }
+     * const rot = { x: 0, y: 0, z: 0 }
+     * const offset = { x: 20, y: 0, z: 0 }
+     *
+     * // Creates the root assembly first
+     * const rootAsm = await api.createRootAssembly('Root_Assembly')
+     *
+     * // Creates a part template and adds geometry to it
+     * const partTempl = await api.createPartAsTemplate('Part_Template')
+     * 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 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;
+    /**
+     * Creates a new work axis for the given part
+     * @param partId id of the part to add the new work axis to
+     * @param type type of the work axis
+     * @param references references for the work axis, needed for all types except 'Custom'
+     * @param position position of axis, only needed if type = 'Custom'
+     * @param direction direction of axis, only needed if type = 'Custom'
+     * @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<number | string>, direction: Vec<number | string>, local: boolean, name?: string) => ID;
+    /**
+     * Creates a new work coordinate system for the given part.
+     * @param partId id of the part to add the new work coord system to
+     * @param type type of the work coordinate system
+     * @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 direction of the primary axis
+     * @param name name of the work coordinate system, if not set default name = 'WorkCoordSystem'
+     * @example
+     * // Defines some consts
+     * const orig = { x: 0, y: 0, z: 0 }
+     * const xDir = { x: 1, y: 0, z: 0 }
+     * const yDir = { x: 0, y: 1, z: 0 }
+     * const rot = { x: 0, y: 0, z: 0 }
+     * const offset1 = { x: 0, y: 0, z: 0 }
+     * const offset2 = { x: 0, y: 0, z: 0 }
+     * const offset3 = { x: 15, y: 15, z: 30 }
+     *
+     * // Creates the root assembly first
+     * const rootAsm = await api.createRootAssembly('Root_Assembly')
+     *
+     * // Creates a part template and adds geometry to it
+     * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
+     * const wcs3 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset3, rot, false, 'wcs3')
+     * api.box(partTempl1, [wcs1], 30, 30, 30)
+     *
+     * // Creates another part template and adds geometry to it
+     * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
+     * 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 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 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<number | string>, rotation: Vec<number | string>, inverted: boolean, name?: string) => ID;
+    /**
+     * Creates a new work plane for the given part
+     * @param partId id of the part to add the new work plane to
+     * @param type type of the work plane
+     * @param references references for the work plane, needed for all types except 'Custom'
+     * @param offset offset in normal direction, can be used for all types except 'LinePlaneAndAngle'
+     * @param angle angle in degrees, needed for type 'LinePlaneAndAngle'
+     * @param position position of plane, only needed if type = 'Custom'
+     * @param normal normal vector of work plane, only needed if type = 'Custom'
+     * @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<number | string>, normal: Vec<number | string>, local: boolean, name?: string) => ID;
+    /**
+     * Creates a new work point for the given part
+     * @param partId id of the part to add the new work point to
+     * @param type type of the work point
+     * @param references references for the work point, needed for all types except 'Custom'
+     * @param position position of point, only needed if type = 'Custom'
+     * @param direction direction of point, only needed if type = 'Custom'
+     * @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<number | string>, local: boolean, name?: string) => ID;
+    /**
+     * Deletes existing expressions.
+     * @param partId id or identifier of part to delete expressions from
+     * @param members name of members to delete
+     * @example
+     * // Deletes an expression from part's expression set
+     * const part = api.createPart('Part')
+     * api.createExpressions(part, { name: 'width', value: 20 }, { name: 'height', value: 40 })
+     * api.deleteExpressions(part, ['height'])
+     * 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>;
+    /**
+     * Loads a sketch from a ofb filestream and adds its elements to a new sketch.
+     * The id of this new created sketch will be returned.
+     *
+     * @param partId id of the part we want to create the new sketch and copy the sketch elements into it
+     * @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;
+    /**
+     * Copy an existing sketch and adds its elements to a new sketch.
+     * The id of this new created sketch will be returned.
+     *
+     * @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;
+    /**
+     * Place/position the sketch with plane, axis and origin references.
+     *
+     * @param sketchId id of the sketch to place
+     * @param planeId - id of a face or a workplane. This will be the plane where the sketch lies on.
+     * If a plane reference already exists, planeId is optional
+     * @param invertPlane - if true, the normal of the plane will be inverted
+     * @param axisId - optional id of an edge or workaxis. This will be the x-Axis
+     * @param isXAxis - if true, the axisId will be the x-axis of the sketch, else the x-Axis will be the crossvector of the normal and the axisId
+     * @param invertAxis - if true, the direction of the axis will be inverted
+     * @param originId - optional point or vertex of the sketch's origin reference
+     */
+    placeSketch: (sketchId: VID, planeId: VID, invertPlane: boolean, axisId: VID, isXAxis: boolean, invertAxis: boolean, originId: VID) => Promise<void>;
+    /**
+     * 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
+     * // Creates a sphere with radius = 20
+     * const part = api.createPart('Part')
+     * 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 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
+     * @example
+     * // Creates a cylinder and puts a fillet at the top edge
+     * const part = api.createPart('Part')
+     * api.cylinder(part, [], 10, 100)
+     * const topEdges = await api.pick(part, 'edge', [{ x: 0, y: 0, z: 100 }])
+     * 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 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 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: <T = GeometryElement>(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.
+     * @param type Type of the geometry to look for
+     * @param positions Array of elements containing one or more positions to look for the geometry
+     * @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 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
+     */
+    getAssemblyTemplate: (asmName?: string) => IDs;
+    /**
+     * 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
+     */
+    getInstance: (id: VID, instanceName?: string) => IDs;
+    /**
+     * Find first instance which can be identified by given identifier or name.
+     * If both optional parameters has been set, the identifier is treated with priority.
+     * If no instance with given identifier will be found, the name is used to find an instance.
+     *
+     * @param drawingId The drawing id.
+     * @param options Optional parameters to identify to find instance.
+     * @param options.instanceIdent Identifier to find the instance by an identifier
+     * @param options.instanceName Name to find the instance by its name
+     * @returns first found instance which meets the searching conditions or null if nothing could be found
+     */
+    findInstance: (options: {
+        instanceIdent?: ObjectIdent;
+        instanceName?: string;
+    }) => ID;
+    /**
+     * 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
+     */
+    getProductsOfInstances: (instanceIds: VID[]) => IDs;
+    /**
+     * Returns the id of the current product
+     * @example // tbd
+     */
+    getCurrentProduct: () => ID;
+    /**
+     * Sets the instance with id to the new current instance
+     *
+     * @param id id of the instance to set as the current
+     * @example // tbd
+     */
+    setCurrentInstance: (id: VID) => Promise<void>;
+    /**
+     * Sets the product with productId to the new current product
+     *
+     * @param productId Id of the product to set as the current
+     * @example // tbd
+     */
+    setCurrentProduct: (productId: VID) => Promise<void>;
+    /**
+     * Returns the id of the current instance
+     * @example // tbd
+     * @return id of the current instance
+     */
+    getCurrentInstance: () => ID;
+    /**
+     * Returns the global transformation of the given id.
+     * Currently only ids of instances supported.
+     *
+     * @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]
+     * ]
+     */
+    getTransformation: (id: VID) => Promise<number[][]>;
+    /**
+     * 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
+     */
+    getPartTemplate: (partName?: string) => IDs;
+    /**
+     * 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
+     * // Adds a loaded part to an assembly. To set the part to the origin of the
+     * // assembly with a constraint, the work coord system can be get from part by name.
+     * const pt0 = { x: 0, y: 0, z: 0 }
+     * const xDir = { x: 1, y: 0, z: 0 }
+     * 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.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: (id: VID, wcsName?: string) => IDs;
+    /**
+     * 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
+     * @example // tbd
+     * @return array containing ids of the sketch regions
+     */
+    getSketchRegion: (id: VID, sketchRegionName?: 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
+     * @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: (id: VID, type: WorkGeomType, wgName?: string) => IDs;
+    /**
+     * 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
+     * @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 ],
+     *    [ reference id of second mate, workcoordsystem id of second mate, flip type of second mate, reoriented type of second mate ],
+     *    xOffset,
+     *    yOffset,
+     *    zOffset
+     * ]
+     */
+    getConstraint: (refId: VID, constrName?: string) => Promise<ConstraintType>;
+    /**
+     * 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
+     * @return found fastened constraint as object.
+     */
+    getFastenedConstraint: (id: VID, constrName: string) => Promise<FastenedConstraintType>;
+    /**
+     * 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
+     * @return found fastened origin constraint as object.
+     */
+    getFastenedOriginConstraint: (id: VID, constrName: string) => Promise<FastenedOriginConstraintType>;
+    /**
+     * 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
+     * @return found revolute constraint as object.
+     */
+    getRevoluteConstraint: (id: VID, constrName: string) => Promise<RevoluteConstraintType>;
+    /**
+     * 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
+     * @return found slider constraint as object.
+     */
+    getSliderConstraint: (id: VID, constrName: string) => Promise<SliderConstraintType>;
+    /**
+     * 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
+     * @return found planar constraint as object.
+     */
+    getPlanarConstraint: (id: VID, constrName: string) => Promise<PlanarConstraintType>;
+    /**
+     * 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
+     * @return found parallel constraint as object.
+     */
+    getParallelConstraint: (id: VID, constrName: string) => Promise<ParallelConstraintType>;
+    /**
+     * 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
+     * @return found cylindrical constraint as object.
+     */
+    getCylindricalConstraint: (id: VID, constrName: string) => Promise<CylindricalConstraintType>;
+    /**
+     * 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 / 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, 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 id id of the part, assembly, instance or solid we want the information from
+     * @example // tbd
+     * @return object containing the geometry information
+     */
+    getGeometryInformation: (id: VID) => Promise<ModelInfo | null>;
+    /**
+     * Writes the current drawing to a stream and returns the data.
+     *
+     * Important notes about the ofb format:
+     *    - It contains binary geometry blocks.
+     *    - Do not try to convert it to text, the geometry blocks will get damaged!
+     *
+     * @param type type to write
+     * @example // tbd
+     * @return stream data
+     */
+    save: (type: 'ofb' | 'stp') => Promise<Uint8Array | null>;
+    /**
+     * 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', 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', options?: {
+        ident?: ObjectIdent;
+    }) => Promise<number[] | null>;
+    /**
+     * 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 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 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 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 instances from root assembly, other instances or assembly templates.
+     * @param instances array of instance objects. See following parameter descriptions.
+     * @param id id, identifier or name of the instance to remove
+     * @example // tbd
+     */
+    removeInstances: (...instances: {
+        id: VID | ObjectIdent;
+    }[]) => Promise<void>;
+    /**
+     * 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, identifier or name of the instance to transform
+     * @param transformation transformation (origin, xDir, yDir) of the instance local to the owner.
+     * @example // tbd
+     */
+    transformInstances: (...instances: {
+        id: VID | ObjectIdent;
+        transformation: Transform;
+    }[]) => Promise<void>;
+    /**
+     * Creates a translate operation
+     * @param partId id ot the part where features 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, operations: VID[], references: VID[], inverted: 0 | 1, distance: number | string) => ID;
+    /**
+     * 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>;
+    /**
+     * Returns found vertices, edges or faces depending on
+     * 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
+     * @example
+     * // Creates a cylinder an puts a fillet on the top edge
+     * const part = api.createPart('Part')
+     * api.cylinder(part, [], 10, 100)
+     * const edges = await api.pick(part, 'edge', [{ x: 0, y: 0, z: 100 }])
+     * 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, identifier or name 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'
+     * @example // tbd
+     * @returns true, if updating expressions in all parts was successfull
+     */
+    setExpressions: (...expressions: {
+        partId: VID | ObjectIdent;
+        members: {
+            name: string;
+            value: number | string;
+        }[];
+    }[]) => Promise<boolean>;
+    /**
+     * 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 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, 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 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 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: (instanceId: VID | ObjectIdent) => 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 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 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 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;
+};
+export declare class History {
+    drawingId: DrawingID | null;
+    queue: Promise<number>;
+    constructor();
+    resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
+    init(callback: (api: ApiHistory) => void): () => Promise<void>;
+    destroy(): void;
+}
+export declare class history extends History {
+    constructor();
+}
+declare type VID = ObjectID | null | Promise<ObjectID | null>;
+declare type VIDs = ObjectID[] | Promise<ObjectID[]>;
+declare type ID = Promise<ObjectID | null>;
+declare type IDs = Promise<ObjectID[]>;
+declare type Point = {
+    x: number;
+    y: number;
+    z: number;
+};
+declare type ModelInfo = {
+    centerOfGravity: Vec;
+    volume: number;
+};
+declare type MateParam = {
+    matePath: VID[];
+    wcsId: VID;
+    flip: FlipType;
+    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 = DimensionParam<VID, Vec>;
+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;
+    /** rotation around x-axis */
+    xRotation?: number | string;
+    /** rotation around y-axis */
+    yRotation?: number | string;
+    /** rotation around z-axis */
+    zRotation?: 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;
+    /** rotation around x-axis */
+    xRotation?: number | string;
+    /** rotation around y-axis */
+    yRotation?: number | string;
+    /** rotation around z-axis */
+    zRotation?: 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 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
+ * ]
+ */
+export declare type ConstraintType = [
+    number,
+    [
+        number[],
+        number,
+        number,
+        number
+    ],
+    [
+        number[],
+        number,
+        number,
+        number
+    ],
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * General, generic vector type representing following types:
+ * - Value[]
+ * - {x: Value, y: Value, z: Value}
+ * - 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<Value = number> = Value[] | {
+    x: Value;
+    y: Value;
+    z: Value;
+} | THREE.Vector3 | THREE.Euler;
+export {};