@buerli.io/headless 0.13.0 → 0.13.1-beta.0

package/build/types/solid.d.ts

@@ -1,519 +1,521 @@
-import { BuerliState, DrawingID, DrawingState, ObjectID } from '@buerli.io/core';
-import { BufferGeometry, Scene, Vector3 } from 'three';
-/**
- * A simple and intuitive javascript based api that incorporates solid operations like
- * shapes, booleans (unions, subtracts, intersections), extrusions, revolves, blends,
- * chamfers, slices, arrays, patterns, offsets, etc. The api is compatible with THREEJS
- * and understands some of its primitives like curves and paths.
- *
- * ```sh
- * npm install @buerli.io/headless
- * ```
- *
- * ```js
- * import { Solid } from '@buerli.io/headless'
- * const cad = new Solid(url)
- * cad.init(async api => {
- *     // Your code goes here
- * })
- * ```
- */
-export declare type ApiNoHistory = {
-    /**
-     * 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>;
-    /**
-     * Creates a simple box.
-     * @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 length = 10, width = 25 and height = 15
-     * const boxId = api.box(10,25,15)
-     * const geom = await api.createBufferGeometry(boxId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/box.jpg
-     */
-    box: (length: number, width: number, height: number) => ID;
-    /**
-     * Clears all existing solids in the drawing.
-     * @example
-     * // Clears all solids
-     * const boxId = api.box(10,25,15)
-     * const coneId = api.cone(50,20,10)
-     * api.clearSolids()
-     * @image // tbd
-     */
-    clearSolids: () => Promise<void>;
-    /**
-     * Clears the target solid in the drawing.
-     * @param solidId id of the solid to be deleted
-     * @example
-     * // Clear a specific solid
-     * const boxId = api.box(10,25,15)
-     * const coneId = api.cone(50,20,10)
-     * api.clearSolid(boxId)
-     * const geom = await api.createBufferGeometry(coneId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image // tbd
-     */
-    clearSolid: (solidId: VID) => Promise<void>;
-    /**
-     * Creates a simple cone.
-     * @param height height of the cone (z-axis)
-     * @param diameter1 diameter at the bottom of the cone
-     * @param diameter2 diameter at the top of the cone
-     * @example
-     * // Creates a cone with height = 50, diameter1 = 20 and diameter2 = 10
-     * const coneId = api.cone(50,20,10)
-     * const geom = await api.createBufferGeometry(coneId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/cone.jpg
-     */
-    cone: (height: number, diameter1: number, diameter2: number) => ID;
-    /**
-     * Creates a copy of the solid.
-     * @param solidId id of the solid to create a copy from
-     * @example
-     * // Creates a copy of a solid
-     * const coneId = api.cone(50,20,10)
-     * const copyId = api.copy(coneId)
-     * api.rotateTo(copyId, [Math.PI / 2, 0, 0])
-     * const unionId = api.union(coneId, false, copyId)
-     * const geom = await api.createBufferGeometry(unionId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/copy.jpg
-     */
-    copy: (solidId: VID) => ID;
-    /**
-     * Creates the buffer geometry of the solid.
-     * @param solidId id of the solid to create buffer geometry from
-     * @example
-     * // Creates the buffer geometry
-     * const coneId = api.cone(50,20,10)
-     * const boxId = api.box(10,25,15)
-     * const unionId = api.union(coneId, false, boxId)
-     * const geom = await api.createBufferGeometry(coneId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image // tbd
-     */
-    createBufferGeometry: (solidId: VID) => Promise<BufferGeometry | undefined>;
-    /**
-     * Creates ThreeJS scene from the given solids.
-     * @param solids ids of the solids to create scene from
-     * @param options optional object to define different settings.
-     * @param meshPerGeometry boolean flag to define if the solids will have a mesh for each geometry element
-     * or if the geometries will be combined to one mesh
-     * @example // tbd
-     * @image // tbd
-     */
-    createScene: (solids: VID[], options?: {
-        meshPerGeometry?: boolean;
-    }) => Promise<{
-        scene: Scene;
-        part: THREE.Group;
-        solids: THREE.Group[];
-        meshes: THREE.Mesh[];
-    }>;
-    /**
-     * Creates a simple cylinder.
-     * @param height height of the cylinder (z-axis)
-     * @param diameter diamter of the cylinder
-     * @example
-     * // Creates a cylinder with height = 50 and diameter = 10
-     * const cylinderId = api.cylinder(50,10)
-     * const geom = await api.createBufferGeometry(cylinderId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/cylinder.jpg
-     */
-    cylinder: (height: number, diameter: number) => ID;
-    /**
-     * Returns all adjacent edges of a face or vertex
-     * @param breps face or vertex ids to get the adjacent edges from
-     * @example
-     * // Returns all edges from the top surface of box and adds a fillet on them
-     * const boxId = api.box(10, 25, 15)
-     * const surface = api.pick(boxId, 'face', [0, 0, 7.5])
-     * const edges = api.edgeLoops(surface)
-     * api.fillet(2, edges)
-     * const geom = await api.createBufferGeometry(boxId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/edgeLoops.jpg
-     */
-    edgeLoops: (breps: VIDs) => IDs;
-    /**
-     * Writes the current solid or specific solids to a stream in stp data format
-     * and returns the data.
-     * @param solidIds [optional] specific solidIds to write to stream
-     * @example
-     * // Writes the unified solid to stream
-     * const coneId = api.cone(50,20,10)
-     * const boxId = api.box(10,25,15)
-     * const unionId = api.union(coneId, false, boxId)
-     * const data = api.export()
-     * const geom = await api.createBufferGeometry(coneId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image // tbd
-     */
-    export: (solidIds?: VIDs) => Promise<Uint8Array | null>;
-    /**
-     * The solid is extended at the defined plane with a solid created by extruding the section defined by the plane.
-     * @param solidId id of the solid which will be extended
-     * @param point position of plane
-     * @param normal normal vector of plane
-     * @param distance distance of extension
-     * @example
-     * // Extends the sphere in its center
-     * const sphereId = api.sphere(10)
-     * api.extendSolidAtPlane(sphereId, [0, 0, 0], [0, 1, 1], 50)
-     * const geom = await api.createBufferGeometry(sphereId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/extendSolidAtPlane.jpg
-     */
-    extendSolidAtPlane: (target: VID, point: Vec, normal: Vec, distance: number) => Promise<void>;
-    /**
-     * Creates an extrusion.
-     * @param height height of extrusion
-     * @param region region which will be extruded, defined by Polyline or THREE.Shape
-     * @example
-     * // Extrudes a heart from THREE shape
-     * const shape = new THREE.Shape()
-     * shape.moveTo(25, 25)
-     * shape.bezierCurveTo(25, 25, 20, 0, 0, 0)
-     * shape.bezierCurveTo(-30, 0, -30, 35, -30, 35)
-     * shape.bezierCurveTo(-30, 55, -10, 77, 25, 95)
-     * shape.bezierCurveTo(60, 77, 80, 55, 80, 35)
-     * shape.bezierCurveTo(80, 35, 80, 0, 50, 0)
-     * shape.bezierCurveTo(35, 0, 25, 25, 25, 25)
-     * const heartId = api.extrude([0, 0, 5], shape)
-     * api.rotateTo(heartId, [Math.PI, 0, 0])
-     * const geom = await api.createBufferGeometry(heartId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/extrude.jpg
-     */
-    extrude: (height: Vec, region: Polyline | THREE.Shape) => ID;
-    /**
-     * Creates a fillet at the given edges
-     * @param radius radius of the fillet
-     * @param edges edges to create fillets on
-     * @example
-     * // Creates a fillet with radius = 2 at the given edge
-     * const boxId = api.box(10, 25, 15)
-     * const edge = api.pick(boxId, 'edge', [5, 0, 7.5])
-     * api.fillet(2, edge)
-     * const geom = await api.createBufferGeometry(boxId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/fillet.jpg
-     */
-    fillet: (radius: number, edges: VIDs) => ID;
-    /**
-     * Loads an arraybuffer in stp file format. All solids existing
-     * in stp data will be returned in an array. Current drawing will not
-     * be overwritten, imports will just be added.
-     * @param data data as arraybuffer in stp format
-     * @example
-     * // Imports a stp file
-     * const importIds = await api.import(arraybuffer)
-     * const geom = await api.createBufferGeometry(importIds[0])
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image // tbd
-     */
-    import: (data: ArrayBuffer) => IDs;
-    /**
-     * Creates an intersection between solid and bodies.
-     * @param solidId id of the solid to intersect
-     * @param keepSolid if true, the solid will be kept and can be used again
-     * @param bodies bodies to intersect with the solid
-     * @example
-     * // Creates an intersection between a sphere and a cylinder
-     * const sphereId = api.sphere(20)
-     * const cylinderId = api.cylinder(50, 30)
-     * const intersectId = api.intersect(sphereId, false, cylinderId)
-     * const geom = await api.createBufferGeometry(intersectId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/intersect.jpg
-     */
-    intersect: (solidId: VID, keepSolid: boolean, ...bodies: VID[]) => ID;
-    /**
-     * Loads an arraybuffer in native file format. Native file format
-     * is 'ofb', if you want to load 'stp' file formats, use import function.
-     * Current drawing will be overwritten by loaded data.
-     * @param data data as arraybuffer in ofb format
-     * @example // tbd
-     * @image // tbd
-     */
-    load: (data: ArrayBuffer) => IDs;
-    /**
-     * Mirrors the solid at the specified plane.
-     * @param point position of the mirror plane
-     * @param normal normal vector of the mirror plane
-     * @example
-     * // Mirrors the cone at its bottom surface
-     * const coneId1 = api.cone(50, 20, 0)
-     * api.mirror(coneId1, [0, 0, -25], [0, 0, 1])
-     * const coneId2 = api.cone(50, 20, 0)
-     * const unionId = api.union(coneId1, false, coneId2)
-     * const geom = await api.createBufferGeometry(unionId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/mirror.jpg
-     */
-    mirror: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
-    /**
-     * Moves the solid to the given position.
-     * @param solidId id of the solid which will be moved
-     * @param position position to move the solid to
-     * @example
-     * // Moves the second box to the first box's corner
-     * const boxId1 = api.box(20, 20, 20)
-     * const boxId2 = api.box(20, 20, 20)
-     * api.moveTo(boxId1, [10, 10, 10])
-     * const unionId = api.union(boxId1, false, boxId2)
-     * const geom = await api.createBufferGeometry(unionId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/moveTo.jpg
-     */
-    moveTo: (solidId: VID, position: Vec) => Promise<void>;
-    /**
-     * Creates an offset of the solid.
-     * @param solidId solid which becomes an offset
-     * @param offsetDistance distance of offset
-     * @example
-     * // Creates an offset on the box
-     * const boxId1 = api.box(20, 20, 20)
-     * api.offset(boxId1, 2)
-     * const geom = await api.createBufferGeometry(boxId1)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/offset.jpg
-     */
-    offset: (solidId: VID, offsetDistance: number) => ID;
-    /**
-     * Returns all edges or faces depending on type which matches the points.
-     * @param solidId id of the solid to look for edges and faces
-     * @param type type of geometry to look for --> 'edge' or 'face'
-     * @param points points where edges and faces will be expected
-     * @example
-     * // Pick does look for an edge at point [5,0,7.5] and adds a fillet on it if found the edge
-     * const boxId = api.box(10, 25, 15)
-     * const edge = api.pick(boxId, 'edge', [5, 0, 7.5])
-     * api.fillet(2, edge)
-     * const geom = await api.createBufferGeometry(boxId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/pick.jpg
-     */
-    pick: (solidId: VID, type: 'vertex' | 'edge' | 'face', ...points: Vec[]) => IDs;
-    /**
-     * Revolves the given region.
-     * @param position position of rotation axis
-     * @param direction direction of rotation axis
-     * @param angle angle of rotation in rad
-     * @param region region which will be revolved, defined by Polyline or THREE.Shape
-     * @example
-     * // Creates a closed polyline from three points and revolves it
-     * const fp0 = { point: new THREE.Vector3(20, 20, 0), radius: 4 }
-     * const fp1 = { point: new THREE.Vector3(40, 0, 0), radius: 2 }
-     * const fp2 = { point: new THREE.Vector3(0, 0, 0), radius: 2 }
-     * const polyline = createPolyline([fp0, fp1, fp2])
-     * const revolveId = api.revolve([-10, 0, 0], [0, 1, 0], 2 * Math.PI, polyline)
-     * const geom = await api.createBufferGeometry(revolveId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/revolve.jpg
-     */
-    revolve: (position: Vec, direction: Vec, angle: number, region: Polyline | THREE.Shape) => ID;
-    /**
-     * Rotates the given solid.
-     * @param solidId id of the solid to rotate
-     * @param rotationVec vector of rotation around x-, y- and z-axis
-     * @example
-     * // Creates a box and rotates it around its x- and z-axis
-     * const boxId = api.box(10, 10, 10)
-     * api.rotateTo(boxId, [Math.PI / 4, 0, Math.PI / 4])
-     * const geom = await api.createBufferGeometry(boxId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/rotateTo.jpg
-     */
-    rotateTo: (solidId: VID, rotationVec: Vec) => Promise<void>;
-    /**
-     * Writes the current drawing as native file format to a stream and returns the data.
-     * Native file is 'ofb', for 'stp' file format use export method.
-     *
-     * 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!
-     *
-     * @example
-     * // Creates a rotated box and gets the ofb data.
-     * const boxId = api.box(10, 10, 10)
-     * api.rotateTo(boxId, [Math.PI / 4, 0, Math.PI / 4])
-     * const data = api.save()
-     *
-     * @image // tbd
-     */
-    save: () => Promise<Uint8Array | null>;
-    /**
-     * Scales the solid in all or specified axis.
-     * @param solidId id of the solid to scale
-     * @param vectorOrFactor if factor is defined, the solid will be scaled in all direction with same scale value. Otherwise in the given x, y and z direction of the vector.
-     * @example
-     * // Creates a box and scales it in x-axis
-     * const boxId = api.box(10, 10, 10)
-     * api.scale(boxId, [2, 1, 1])
-     * const geom = await api.createBufferGeometry(boxId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/scale.jpg
-     */
-    scale: (solidId: VID, vectorOrFactor: Vec | number) => Promise<void>;
-    /**
-     * Sets the faceting parameters of graphic objects. This defines how detailed solids will be displayed.
-     * @param distanceTol tolerated distance between theoretic and tesselated arc
-     * @param angleTol tolerated angle between normal vectors of faces which build an arc
-     * @example
-     * // Creates a cylinder with low tessellation
-     * api.setFacetingParams(0.5, 0)
-     * const cylinderId = api.cylinder(50, 20)
-     * const geom = await api.createBufferGeometry(cylinderId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/setFacetingParams.jpg
-     */
-    setFacetingParams: (distanceTol: number, angleTol: number) => ID;
-    /**
-     * Slices the solid at specified plane. Part of solid which is on the positive side of defined plane will be removed.
-     * @param solidId id of solid to slice
-     * @param point position of plane
-     * @param normal normal vector of plane
-     * @example
-     * // Creates a sphere and slice it
-     * const sphereId = api.sphere(20)
-     * api.slice(sphereId, [10, 10, 0], [1, 1, 0])
-     * const geom = await api.createBufferGeometry(sphereId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/slice.jpg
-     */
-    slice: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
-    /**
-     * Creates a simple sphere.
-     * @param radius radius of the sphere
-     * @example
-     * // Creates a sphere with radius = 10
-     * const sphereId = api.sphere(10)
-     * const geom = await api.createBufferGeometry(sphereId)
-     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/sphere.jpg
-     */
-    sphere: (radius: number) => ID;
-    /**
-     * Creates a subtraction between solid and bodies.
-     * @param solidId id of the solid to subtract
-     * @param keepSolid if true, the solid will be kept and can be used again
-     * @param bodies bodies to subtract from the solid
-     * @example
-     * // Subtracts a box from sphere after
-     * const sphereId = api.sphere(20)
-     * const boxId = api.box(20, 20, 20)
-     * api.moveTo(boxId, [10, 10, 10])
-     * const subId = api.subtract(sphereId, false, boxId)
-     * const geom = await api.createBufferGeometry(subId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/subtract.jpg
-     */
-    subtract: (solidId: VID, keepSolid: boolean, ...bodies: VID[]) => ID;
-    /**
-     * Creates an union between solid and bodies.
-     * @param solidId id of the solid to unify
-     * @param keepSolid if true, the solid will be kept and can be used again
-     * @param bodies bodies to unify with the solid
-     * @example
-     * // Unifies a sphere with a cone
-     * const sphereId = api.sphere(20)
-     * const coneId = api.cone(50, 40, 0)
-     * api.moveTo(coneId, [0, 0, 25])
-     * const unionId = api.union(sphereId, false, coneId)
-     * const geom = await api.createBufferGeometry(unionId)
-     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
-     * @image /doc/assets/solid/union.jpg
-     */
-    union: (solidId: VID, keepSolid: boolean, ...bodies: VID[]) => ID;
-};
-/**
- * Creates a polyline from the given fillet points
- * @param fPts points of the polyline with its associated fillet radius
- * @example
- * // Creates a polyline with three points
- * const fp0 = { point: new THREE.Vector3(20, 20, 0), radius: 4 }
- * const fp1 = { point: new THREE.Vector3(40, 0, 0), radius: 2 }
- * const fp2 = { point: new THREE.Vector3(0, 0, 0), radius: 2 }
- * const polyline = createPolyline([fp0, fp1, fp2])
- */
-export declare function createPolyline(fPts: FilletPoint[]): Polyline;
-export declare class Solid {
-    drawingId: DrawingID | null;
-    queue: Promise<number>;
-    constructor();
-    resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
-    init(callback: (api: ApiNoHistory) => void): () => Promise<void>;
-    destroy(): void;
-}
-export declare class solid extends Solid {
-    constructor();
-}
-declare type VID = ObjectID | Promise<ObjectID>;
-declare type VIDs = ObjectID[] | Promise<ObjectID[]>;
-declare type ID = Promise<ObjectID>;
-declare type IDs = Promise<ObjectID[]>;
-declare type Vec = number[] | THREE.Vector3 | THREE.Euler;
-/**
- * Point definition where the fillet will be added with a specified radius.
- */
-export declare type FilletPoint = {
-    /** Point where the corner of the polyline will be. */
-    point: Vector3;
-    /** Radius of the fillet at the position of point. */
-    radius: number;
-};
-/**
- * Polyline of points and bulges. Bulges define the arc between the current and the next point.
- */
-export declare type Polyline = {
-    /** Points where the corners of the polyline will be. */
-    points: Vector3[];
-    /** Bulges which define the arcs. */
-    bulges: number[];
-};
-export {};
+import { BuerliState, DrawingID, DrawingState, ObjectID } from '@buerli.io/core';
+import { BufferGeometry, Scene, Vector3 } from 'three';
+/**
+ * A simple and intuitive javascript based api that incorporates solid operations like
+ * shapes, booleans (unions, subtracts, intersections), extrusions, revolves, blends,
+ * chamfers, slices, arrays, patterns, offsets, etc. The api is compatible with THREEJS
+ * and understands some of its primitives like curves and paths.
+ *
+ * ```sh
+ * npm install @buerli.io/headless
+ * ```
+ *
+ * ```js
+ * import { init, Solid } from '@buerli.io/headless'
+ *
+ * init('ws://localhost:9091')
+ * const cad = new Solid()
+ * cad.init(async api => {
+ *     // Your code goes here
+ * })
+ * ```
+ */
+export declare type ApiNoHistory = {
+    /**
+     * 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>;
+    /**
+     * Creates a simple box.
+     * @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 length = 10, width = 25 and height = 15
+     * const boxId = api.box(10,25,15)
+     * const geom = await api.createBufferGeometry(boxId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/box.jpg
+     */
+    box: (length: number, width: number, height: number) => ID;
+    /**
+     * Clears all existing solids in the drawing.
+     * @example
+     * // Clears all solids
+     * const boxId = api.box(10,25,15)
+     * const coneId = api.cone(50,20,10)
+     * api.clearSolids()
+     * @image // tbd
+     */
+    clearSolids: () => Promise<void>;
+    /**
+     * Clears the target solid in the drawing.
+     * @param solidId id of the solid to be deleted
+     * @example
+     * // Clear a specific solid
+     * const boxId = api.box(10,25,15)
+     * const coneId = api.cone(50,20,10)
+     * api.clearSolid(boxId)
+     * const geom = await api.createBufferGeometry(coneId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image // tbd
+     */
+    clearSolid: (solidId: VID) => Promise<void>;
+    /**
+     * Creates a simple cone.
+     * @param height height of the cone (z-axis)
+     * @param diameter1 diameter at the bottom of the cone
+     * @param diameter2 diameter at the top of the cone
+     * @example
+     * // Creates a cone with height = 50, diameter1 = 20 and diameter2 = 10
+     * const coneId = api.cone(50,20,10)
+     * const geom = await api.createBufferGeometry(coneId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/cone.jpg
+     */
+    cone: (height: number, diameter1: number, diameter2: number) => ID;
+    /**
+     * Creates a copy of the solid.
+     * @param solidId id of the solid to create a copy from
+     * @example
+     * // Creates a copy of a solid
+     * const coneId = api.cone(50,20,10)
+     * const copyId = api.copy(coneId)
+     * api.rotateTo(copyId, [Math.PI / 2, 0, 0])
+     * const unionId = api.union(coneId, false, copyId)
+     * const geom = await api.createBufferGeometry(unionId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/copy.jpg
+     */
+    copy: (solidId: VID) => ID;
+    /**
+     * Creates the buffer geometry of the solid.
+     * @param solidId id of the solid to create buffer geometry from
+     * @example
+     * // Creates the buffer geometry
+     * const coneId = api.cone(50,20,10)
+     * const boxId = api.box(10,25,15)
+     * const unionId = api.union(coneId, false, boxId)
+     * const geom = await api.createBufferGeometry(coneId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image // tbd
+     */
+    createBufferGeometry: (solidId: VID) => Promise<BufferGeometry | undefined>;
+    /**
+     * Creates ThreeJS scene from the given solids.
+     * @param solids ids of the solids to create scene from
+     * @param options optional object to define different settings.
+     * @param meshPerGeometry boolean flag to define if the solids will have a mesh for each geometry element
+     * or if the geometries will be combined to one mesh
+     * @example // tbd
+     * @image // tbd
+     */
+    createScene: (solids: VID[], options?: {
+        meshPerGeometry?: boolean;
+    }) => Promise<{
+        scene: Scene;
+        part: THREE.Group;
+        solids: THREE.Group[];
+        meshes: THREE.Mesh[];
+    }>;
+    /**
+     * Creates a simple cylinder.
+     * @param height height of the cylinder (z-axis)
+     * @param diameter diamter of the cylinder
+     * @example
+     * // Creates a cylinder with height = 50 and diameter = 10
+     * const cylinderId = api.cylinder(50,10)
+     * const geom = await api.createBufferGeometry(cylinderId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/cylinder.jpg
+     */
+    cylinder: (height: number, diameter: number) => ID;
+    /**
+     * Returns all adjacent edges of a face or vertex
+     * @param breps face or vertex ids to get the adjacent edges from
+     * @example
+     * // Returns all edges from the top surface of box and adds a fillet on them
+     * const boxId = api.box(10, 25, 15)
+     * const surface = api.pick(boxId, 'face', [0, 0, 7.5])
+     * const edges = api.edgeLoops(surface)
+     * api.fillet(2, edges)
+     * const geom = await api.createBufferGeometry(boxId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/edgeLoops.jpg
+     */
+    edgeLoops: (breps: VIDs) => IDs;
+    /**
+     * Writes the current solid or specific solids to a stream in stp data format
+     * and returns the data.
+     * @param solidIds [optional] specific solidIds to write to stream
+     * @example
+     * // Writes the unified solid to stream
+     * const coneId = api.cone(50,20,10)
+     * const boxId = api.box(10,25,15)
+     * const unionId = api.union(coneId, false, boxId)
+     * const data = api.export()
+     * const geom = await api.createBufferGeometry(coneId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image // tbd
+     */
+    export: (solidIds?: VIDs) => Promise<Uint8Array | null>;
+    /**
+     * The solid is extended at the defined plane with a solid created by extruding the section defined by the plane.
+     * @param solidId id of the solid which will be extended
+     * @param point position of plane
+     * @param normal normal vector of plane
+     * @param distance distance of extension
+     * @example
+     * // Extends the sphere in its center
+     * const sphereId = api.sphere(10)
+     * api.extendSolidAtPlane(sphereId, [0, 0, 0], [0, 1, 1], 50)
+     * const geom = await api.createBufferGeometry(sphereId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/extendSolidAtPlane.jpg
+     */
+    extendSolidAtPlane: (target: VID, point: Vec, normal: Vec, distance: number) => Promise<void>;
+    /**
+     * Creates an extrusion.
+     * @param height height of extrusion
+     * @param region region which will be extruded, defined by Polyline or THREE.Shape
+     * @example
+     * // Extrudes a heart from THREE shape
+     * const shape = new THREE.Shape()
+     * shape.moveTo(25, 25)
+     * shape.bezierCurveTo(25, 25, 20, 0, 0, 0)
+     * shape.bezierCurveTo(-30, 0, -30, 35, -30, 35)
+     * shape.bezierCurveTo(-30, 55, -10, 77, 25, 95)
+     * shape.bezierCurveTo(60, 77, 80, 55, 80, 35)
+     * shape.bezierCurveTo(80, 35, 80, 0, 50, 0)
+     * shape.bezierCurveTo(35, 0, 25, 25, 25, 25)
+     * const heartId = api.extrude([0, 0, 5], shape)
+     * api.rotateTo(heartId, [Math.PI, 0, 0])
+     * const geom = await api.createBufferGeometry(heartId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/extrude.jpg
+     */
+    extrude: (height: Vec, region: Polyline | THREE.Shape) => ID;
+    /**
+     * Creates a fillet at the given edges
+     * @param radius radius of the fillet
+     * @param edges edges to create fillets on
+     * @example
+     * // Creates a fillet with radius = 2 at the given edge
+     * const boxId = api.box(10, 25, 15)
+     * const edge = api.pick(boxId, 'edge', [5, 0, 7.5])
+     * api.fillet(2, edge)
+     * const geom = await api.createBufferGeometry(boxId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/fillet.jpg
+     */
+    fillet: (radius: number, edges: VIDs) => ID;
+    /**
+     * Loads an arraybuffer in stp file format. All solids existing
+     * in stp data will be returned in an array. Current drawing will not
+     * be overwritten, imports will just be added.
+     * @param data data as arraybuffer in stp format
+     * @example
+     * // Imports a stp file
+     * const importIds = await api.import(arraybuffer)
+     * const geom = await api.createBufferGeometry(importIds[0])
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image // tbd
+     */
+    import: (data: ArrayBuffer) => IDs;
+    /**
+     * Creates an intersection between solid and bodies.
+     * @param solidId id of the solid to intersect
+     * @param keepSolid if true, the solid will be kept and can be used again
+     * @param bodies bodies to intersect with the solid
+     * @example
+     * // Creates an intersection between a sphere and a cylinder
+     * const sphereId = api.sphere(20)
+     * const cylinderId = api.cylinder(50, 30)
+     * const intersectId = api.intersect(sphereId, false, cylinderId)
+     * const geom = await api.createBufferGeometry(intersectId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/intersect.jpg
+     */
+    intersect: (solidId: VID, keepSolid: boolean, ...bodies: VID[]) => ID;
+    /**
+     * Loads an arraybuffer in native file format. Native file format
+     * is 'ofb', if you want to load 'stp' file formats, use import function.
+     * Current drawing will be overwritten by loaded data.
+     * @param data data as arraybuffer in ofb format
+     * @example // tbd
+     * @image // tbd
+     */
+    load: (data: ArrayBuffer) => IDs;
+    /**
+     * Mirrors the solid at the specified plane.
+     * @param point position of the mirror plane
+     * @param normal normal vector of the mirror plane
+     * @example
+     * // Mirrors the cone at its bottom surface
+     * const coneId1 = api.cone(50, 20, 0)
+     * api.mirror(coneId1, [0, 0, -25], [0, 0, 1])
+     * const coneId2 = api.cone(50, 20, 0)
+     * const unionId = api.union(coneId1, false, coneId2)
+     * const geom = await api.createBufferGeometry(unionId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/mirror.jpg
+     */
+    mirror: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
+    /**
+     * Moves the solid to the given position.
+     * @param solidId id of the solid which will be moved
+     * @param position position to move the solid to
+     * @example
+     * // Moves the second box to the first box's corner
+     * const boxId1 = api.box(20, 20, 20)
+     * const boxId2 = api.box(20, 20, 20)
+     * api.moveTo(boxId1, [10, 10, 10])
+     * const unionId = api.union(boxId1, false, boxId2)
+     * const geom = await api.createBufferGeometry(unionId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/moveTo.jpg
+     */
+    moveTo: (solidId: VID, position: Vec) => Promise<void>;
+    /**
+     * Creates an offset of the solid.
+     * @param solidId solid which becomes an offset
+     * @param offsetDistance distance of offset
+     * @example
+     * // Creates an offset on the box
+     * const boxId1 = api.box(20, 20, 20)
+     * api.offset(boxId1, 2)
+     * const geom = await api.createBufferGeometry(boxId1)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/offset.jpg
+     */
+    offset: (solidId: VID, offsetDistance: number) => ID;
+    /**
+     * Returns all edges or faces depending on type which matches the points.
+     * @param solidId id of the solid to look for edges and faces
+     * @param type type of geometry to look for --> 'edge' or 'face'
+     * @param points points where edges and faces will be expected
+     * @example
+     * // Pick does look for an edge at point [5,0,7.5] and adds a fillet on it if found the edge
+     * const boxId = api.box(10, 25, 15)
+     * const edge = api.pick(boxId, 'edge', [5, 0, 7.5])
+     * api.fillet(2, edge)
+     * const geom = await api.createBufferGeometry(boxId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/pick.jpg
+     */
+    pick: (solidId: VID, type: 'vertex' | 'edge' | 'face', ...points: Vec[]) => IDs;
+    /**
+     * Revolves the given region.
+     * @param position position of rotation axis
+     * @param direction direction of rotation axis
+     * @param angle angle of rotation in rad
+     * @param region region which will be revolved, defined by Polyline or THREE.Shape
+     * @example
+     * // Creates a closed polyline from three points and revolves it
+     * const fp0 = { point: new THREE.Vector3(20, 20, 0), radius: 4 }
+     * const fp1 = { point: new THREE.Vector3(40, 0, 0), radius: 2 }
+     * const fp2 = { point: new THREE.Vector3(0, 0, 0), radius: 2 }
+     * const polyline = createPolyline([fp0, fp1, fp2])
+     * const revolveId = api.revolve([-10, 0, 0], [0, 1, 0], 2 * Math.PI, polyline)
+     * const geom = await api.createBufferGeometry(revolveId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/revolve.jpg
+     */
+    revolve: (position: Vec, direction: Vec, angle: number, region: Polyline | THREE.Shape) => ID;
+    /**
+     * Rotates the given solid.
+     * @param solidId id of the solid to rotate
+     * @param rotationVec vector of rotation around x-, y- and z-axis
+     * @example
+     * // Creates a box and rotates it around its x- and z-axis
+     * const boxId = api.box(10, 10, 10)
+     * api.rotateTo(boxId, [Math.PI / 4, 0, Math.PI / 4])
+     * const geom = await api.createBufferGeometry(boxId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/rotateTo.jpg
+     */
+    rotateTo: (solidId: VID, rotationVec: Vec) => Promise<void>;
+    /**
+     * Writes the current drawing as native file format to a stream and returns the data.
+     * Native file is 'ofb', for 'stp' file format use export method.
+     *
+     * 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!
+     *
+     * @example
+     * // Creates a rotated box and gets the ofb data.
+     * const boxId = api.box(10, 10, 10)
+     * api.rotateTo(boxId, [Math.PI / 4, 0, Math.PI / 4])
+     * const data = api.save()
+     *
+     * @image // tbd
+     */
+    save: () => Promise<Uint8Array | null>;
+    /**
+     * Scales the solid in all or specified axis.
+     * @param solidId id of the solid to scale
+     * @param vectorOrFactor if factor is defined, the solid will be scaled in all direction with same scale value. Otherwise in the given x, y and z direction of the vector.
+     * @example
+     * // Creates a box and scales it in x-axis
+     * const boxId = api.box(10, 10, 10)
+     * api.scale(boxId, [2, 1, 1])
+     * const geom = await api.createBufferGeometry(boxId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/scale.jpg
+     */
+    scale: (solidId: VID, vectorOrFactor: Vec | number) => Promise<void>;
+    /**
+     * Sets the faceting parameters of graphic objects. This defines how detailed solids will be displayed.
+     * @param distanceTol tolerated distance between theoretic and tesselated arc
+     * @param angleTol tolerated angle between normal vectors of faces which build an arc
+     * @example
+     * // Creates a cylinder with low tessellation
+     * api.setFacetingParams(0.5, 0)
+     * const cylinderId = api.cylinder(50, 20)
+     * const geom = await api.createBufferGeometry(cylinderId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/setFacetingParams.jpg
+     */
+    setFacetingParams: (distanceTol: number, angleTol: number) => ID;
+    /**
+     * Slices the solid at specified plane. Part of solid which is on the positive side of defined plane will be removed.
+     * @param solidId id of solid to slice
+     * @param point position of plane
+     * @param normal normal vector of plane
+     * @example
+     * // Creates a sphere and slice it
+     * const sphereId = api.sphere(20)
+     * api.slice(sphereId, [10, 10, 0], [1, 1, 0])
+     * const geom = await api.createBufferGeometry(sphereId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/slice.jpg
+     */
+    slice: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
+    /**
+     * Creates a simple sphere.
+     * @param radius radius of the sphere
+     * @example
+     * // Creates a sphere with radius = 10
+     * const sphereId = api.sphere(10)
+     * const geom = await api.createBufferGeometry(sphereId)
+     * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/sphere.jpg
+     */
+    sphere: (radius: number) => ID;
+    /**
+     * Creates a subtraction between solid and bodies.
+     * @param solidId id of the solid to subtract
+     * @param keepSolid if true, the solid will be kept and can be used again
+     * @param bodies bodies to subtract from the solid
+     * @example
+     * // Subtracts a box from sphere after
+     * const sphereId = api.sphere(20)
+     * const boxId = api.box(20, 20, 20)
+     * api.moveTo(boxId, [10, 10, 10])
+     * const subId = api.subtract(sphereId, false, boxId)
+     * const geom = await api.createBufferGeometry(subId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/subtract.jpg
+     */
+    subtract: (solidId: VID, keepSolid: boolean, ...bodies: VID[]) => ID;
+    /**
+     * Creates an union between solid and bodies.
+     * @param solidId id of the solid to unify
+     * @param keepSolid if true, the solid will be kept and can be used again
+     * @param bodies bodies to unify with the solid
+     * @example
+     * // Unifies a sphere with a cone
+     * const sphereId = api.sphere(20)
+     * const coneId = api.cone(50, 40, 0)
+     * api.moveTo(coneId, [0, 0, 25])
+     * const unionId = api.union(sphereId, false, coneId)
+     * const geom = await api.createBufferGeometry(unionId)
+     * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
+     * @image /doc/assets/solid/union.jpg
+     */
+    union: (solidId: VID, keepSolid: boolean, ...bodies: VID[]) => ID;
+};
+/**
+ * Creates a polyline from the given fillet points
+ * @param fPts points of the polyline with its associated fillet radius
+ * @example
+ * // Creates a polyline with three points
+ * const fp0 = { point: new THREE.Vector3(20, 20, 0), radius: 4 }
+ * const fp1 = { point: new THREE.Vector3(40, 0, 0), radius: 2 }
+ * const fp2 = { point: new THREE.Vector3(0, 0, 0), radius: 2 }
+ * const polyline = createPolyline([fp0, fp1, fp2])
+ */
+export declare function createPolyline(fPts: FilletPoint[]): Polyline;
+export declare class Solid {
+    drawingId: DrawingID | null;
+    queue: Promise<number>;
+    constructor();
+    resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
+    init(callback: (api: ApiNoHistory) => void): () => Promise<void>;
+    destroy(): void;
+}
+export declare class solid extends Solid {
+    constructor();
+}
+declare type VID = ObjectID | Promise<ObjectID>;
+declare type VIDs = ObjectID[] | Promise<ObjectID[]>;
+declare type ID = Promise<ObjectID>;
+declare type IDs = Promise<ObjectID[]>;
+declare type Vec = number[] | THREE.Vector3 | THREE.Euler;
+/**
+ * Point definition where the fillet will be added with a specified radius.
+ */
+export declare type FilletPoint = {
+    /** Point where the corner of the polyline will be. */
+    point: Vector3;
+    /** Radius of the fillet at the position of point. */
+    radius: number;
+};
+/**
+ * Polyline of points and bulges. Bulges define the arc between the current and the next point.
+ */
+export declare type Polyline = {
+    /** Points where the corners of the polyline will be. */
+    points: Vector3[];
+    /** Bulges which define the arcs. */
+    bulges: number[];
+};
+export {};