opengeometry 2.0.17 → 3.0.0

package/package.json

@@ -1,54 +1,74 @@
 {
   "name": "opengeometry",
-  "version": "2.0.17",
-  "description": "CAD geometry kernel for the web built with Rust, WebAssembly, and Three.js.",
-  "author": "Vishwajeet Vinayak Mane",
-  "license": "MPL-2.0",
-  "type": "module",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "default": "./index.js"
-    },
-    "./opengeometry/pkg/opengeometry": {
-      "types": "./opengeometry/pkg/opengeometry.d.ts",
-      "import": "./opengeometry/pkg/opengeometry.js",
-      "default": "./opengeometry/pkg/opengeometry.js"
-    },
-    "./opengeometry_bg.wasm": "./opengeometry_bg.wasm",
-    "./analytic-worker.js": "./analytic-worker.js",
-    "./package.json": "./package.json"
-  },
+  "version": "3.0.0",
+  "description": "Open-source CAD kernel for the web and Node.js: exact B-rep solids, booleans, extrude, sweep, revolve, shell and STEP export, in Rust and WebAssembly with a TypeScript SDK for Three.js. For configurators, mechanical parts, buildings, robotics and AI agents.",
   "keywords": [
     "opengeometry",
     "cad",
     "cad-kernel",
-    "browser-cad",
+    "geometry-kernel",
+    "brep",
+    "b-rep",
+    "solid-modeling",
+    "parametric",
+    "parametric-modeling",
+    "procedural-modeling",
+    "boolean",
+    "boolean-operations",
+    "csg",
+    "extrude",
+    "sweep",
+    "revolve",
+    "shell",
+    "step",
+    "step-export",
+    "stp",
     "threejs",
-    "three.js",
-    "geometry",
+    "three",
     "webassembly",
     "wasm",
+    "rust",
+    "typescript",
+    "browser",
+    "browser-cad",
+    "nodejs",
+    "3d",
+    "configurator",
+    "product-configurator",
+    "mechanical-design",
+    "manufacturing",
+    "architecture",
+    "aec",
     "ifc",
-    "step",
-    "stl",
-    "parametric-modeling"
+    "robotics",
+    "ai-cad",
+    "text-to-cad",
+    "ai-agents",
+    "llm"
   ],
+  "homepage": "https://opengeometry.io?utm_source=npm",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/OpenGeometry-io/OpenGeometry.git"
+    "url": "git+https://github.com/OpenGeometry-io/OpenGeometry.git",
+    "directory": "main"
   },
   "bugs": {
     "url": "https://github.com/OpenGeometry-io/OpenGeometry/issues"
   },
-  "homepage": "https://docs.opengeometry.io",
-  "peerDependencies": {
-    "three": ">=0.168.0"
+  "license": "MPL-2.0",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./tessellation-worker.js": "./tessellation-worker.js",
+    "./opengeometry_bg.wasm": "./opengeometry_bg.wasm",
+    "./package.json": "./package.json"
   },
-  "dependencies": {
-    "uuid": "^10.0.0"
+  "peerDependencies": {
+    "three": ">=0.168.0 <0.185.0"
   }
 }

package/src/bodies/body-factory.d.ts

@@ -0,0 +1,3 @@
+import type { BodyOptions } from './body-options.js';
+export declare function existingParams(ogId: string): Record<string, unknown>;
+export declare function createBody(kind: string, params: Record<string, unknown>, options: BodyOptions, bodyType: 'Wire' | 'Sheet' | 'Solid'): string;

package/src/bodies/body-options.d.ts

@@ -0,0 +1,19 @@
+import type { SystemAssembly } from './system-assembly.js';
+export type BodyOptions = {
+    ogId?: string;
+    parent?: SystemAssembly;
+    plane?: {
+        origin?: [number, number, number];
+        normal?: [number, number, number];
+        xDirection?: [number, number, number];
+    };
+    appearance?: Partial<Appearance>;
+};
+export type Appearance = {
+    color: number;
+    opacity: number;
+    outline: boolean;
+    pickOutline: boolean;
+    deflection?: number;
+    smoothAngle?: number;
+};

package/src/bodies/body-placement.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three';
+export type PoseMemory = {
+    position: THREE.Vector3;
+    quaternion: THREE.Quaternion;
+    scale: THREE.Vector3;
+    parentWorld: THREE.Matrix4;
+};
+export declare function poseMemory(): PoseMemory;
+export declare function derivePose(memory: PoseMemory, object: THREE.Object3D): void;
+export declare function keepPose(memory: PoseMemory, object: THREE.Object3D, ogId: string): void;

package/src/bodies/body-registry.d.ts

@@ -0,0 +1,3 @@
+import type { Body } from './body.js';
+export declare function register(body: Body): void;
+export declare function unregister(body: Body): void;

package/src/bodies/body.d.ts

@@ -0,0 +1,71 @@
+import * as THREE from 'three';
+import type { Brep } from '../dto/brep.js';
+import type { Measure, Validity } from '../dto/measure.js';
+import type { MirrorPlane } from '../dto/mirror.js';
+import type { NodeInfo } from '../dto/node-info.js';
+import type { Placement } from '../dto/placement.js';
+import type { GeometryRecord } from '../rendering/records/geometry-record.js';
+import type { Appearance, BodyOptions } from './body-options.js';
+import type { PointClassification } from './node-methods.js';
+import type { SystemAssembly } from './system-assembly.js';
+export type BodyEventMap = THREE.Object3DEventMap & {
+    geometrychanged: object;
+    placementchanged: object;
+};
+export declare abstract class Body extends THREE.Group<BodyEventMap> {
+    readonly ogId: string;
+    readonly handle: number;
+    readonly generation: number;
+    readonly surface: THREE.Mesh;
+    readonly outline: THREE.LineSegments;
+    readonly bodyType: 'Wire' | 'Sheet' | 'Solid';
+    appearance: Appearance;
+    lastInfo: NodeInfo;
+    record?: GeometryRecord;
+    inLimbo: boolean;
+    private surfaceKey;
+    private lineKey;
+    private readonly epoch;
+    private readonly pose;
+    protected constructor(ogId: string, bodyType: 'Wire' | 'Sheet' | 'Solid', options: BodyOptions);
+    protected check(call: string): void;
+    applyWorldMatrix(values: ArrayLike<number>): void;
+    updateMatrixWorld(force?: boolean): void;
+    swapReadyRecord(): void;
+    install(record: GeometryRecord): void;
+    setAppearance(partial: Partial<Appearance>): void;
+    transform(kind: string, params: Record<string, unknown>): void;
+    getPlacement(): Placement;
+    getWorldPlacement(): Placement;
+    addChild(children: (Body | SystemAssembly)[], options?: {
+        keepWorld?: boolean;
+    }): void;
+    removeChild(child: Body | SystemAssembly, options?: {
+        keepWorld?: boolean;
+    }): void;
+    getChildren(): string[];
+    getParent(): string | null;
+    getBounds(): [number, number, number, number, number, number] | null;
+    getBrep(): Brep;
+    getWorldBrep(): Brep;
+    faceNormalAt(faceId: number, point: [number, number, number]): [number, number, number];
+    classifyPoint(point: [number, number, number]): PointClassification;
+    measure(options?: {
+        deflection?: number;
+    }): Measure;
+    mirror(plane: MirrorPlane, options?: {
+        instances?: 'all';
+    }): void;
+    validity(): Validity;
+    getInstanceCount(): number;
+    makeUnique(): void;
+    rebuild(kind: string, params: Record<string, unknown>, options?: {
+        instances?: 'all';
+    }): void;
+    hideForDispose(): void;
+    reviveIfRestored(): void;
+    finalize(): void;
+    dispose(): void;
+    clone(): this;
+    copy(): this;
+}

package/src/bodies/display-clone.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three';
+import type { GeometryRecord } from '../rendering/records/geometry-record.js';
+export declare class DisplayClone extends THREE.Group {
+    readonly sourceRecord: GeometryRecord | undefined;
+    readonly mesh: THREE.Mesh<THREE.BufferGeometry, THREE.Material>;
+    readonly lines: THREE.LineSegments<THREE.BufferGeometry, THREE.Material>;
+    constructor(sourceRecord: GeometryRecord | undefined, mesh: THREE.Mesh<THREE.BufferGeometry, THREE.Material>, lines: THREE.LineSegments<THREE.BufferGeometry, THREE.Material>);
+    dispose(): void;
+    clone(): this;
+}

package/src/bodies/node-methods.d.ts

@@ -0,0 +1,30 @@
+import type { Bounds } from '../dto/bounds.js';
+import type { Brep } from '../dto/brep.js';
+import type { Measure, Validity } from '../dto/measure.js';
+import type { MirrorPlane } from '../dto/mirror.js';
+import type { Placement } from '../dto/placement.js';
+export declare function checkNode(label: string, noun: string, epoch: number, handle: number, generation: number): void;
+export declare function getPlacement(owner: string, ogId: string): Placement;
+export declare function getWorldPlacement(owner: string, ogId: string): Placement;
+export declare function transformNode(owner: string, ogId: string, kind: string, params: Record<string, unknown>): void;
+export declare function addChild(owner: string, ogId: string, children: {
+    ogId: string;
+}[], keepWorld: boolean): void;
+export declare function removeChild(owner: string, ogId: string, childId: string, keepWorld: boolean): void;
+export declare function getChildren(owner: string, ogId: string): string[];
+export declare function getParent(owner: string, ogId: string): string | null;
+export declare function getBounds(owner: string, ogId: string): Bounds | null;
+export declare function localBounds(label: string, ogId: string): Bounds | null;
+export declare function getBrep(owner: string, ogId: string): Brep;
+export declare function getWorldBrep(owner: string, ogId: string): Brep;
+export declare function faceNormalAt(owner: string, ogId: string, faceId: number, point: [number, number, number]): [number, number, number];
+export type PointClassification = 'Inside' | 'Outside' | 'Boundary' | 'Unknown';
+export declare function classifyPoint(owner: string, ogId: string, point: [number, number, number]): PointClassification;
+export declare function getInstanceCount(owner: string, ogId: string): number;
+export declare function measure(owner: string, ogId: string, options: {
+    deflection?: number;
+}): Measure;
+export declare function validity(owner: string, ogId: string): Validity;
+export declare function mirror(owner: string, ogId: string, plane: MirrorPlane, options: {
+    instances?: 'all';
+}): void;

package/src/bodies/sheet.d.ts

@@ -0,0 +1,14 @@
+import { Body } from './body.js';
+import type { BodyOptions } from './body-options.js';
+import type { SystemAssembly } from './system-assembly.js';
+export declare class Sheet extends Body {
+    constructor(kind: string, params: Record<string, unknown>, options?: BodyOptions);
+    instance(options?: {
+        ogId?: string;
+        parent?: SystemAssembly;
+    }): Sheet;
+    duplicate(options?: {
+        ogId?: string;
+        parent?: SystemAssembly;
+    }): Sheet;
+}

package/src/bodies/solid.d.ts

@@ -0,0 +1,23 @@
+import type { ShapeReport } from '../dto/boolean-report.js';
+import { Body } from './body.js';
+import type { BodyOptions } from './body-options.js';
+import type { SystemAssembly } from './system-assembly.js';
+export declare class Solid extends Body {
+    constructor(kind: string, params: Record<string, unknown>, options?: BodyOptions);
+    operate(kind: string, options: {
+        tools: Solid[];
+        instances?: 'all';
+    } | {
+        thickness: number;
+        instances?: 'all';
+    }): void;
+    getReport(): ShapeReport | null;
+    instance(options?: {
+        ogId?: string;
+        parent?: SystemAssembly;
+    }): Solid;
+    duplicate(options?: {
+        ogId?: string;
+        parent?: SystemAssembly;
+    }): Solid;
+}

package/src/bodies/system-assembly.d.ts

@@ -0,0 +1,26 @@
+import type { Placement } from '../dto/placement.js';
+import type { Body } from './body.js';
+export declare class SystemAssembly {
+    readonly ogId: string;
+    readonly handle: number;
+    readonly generation: number;
+    private readonly epoch;
+    constructor(options?: {
+        ogId?: string;
+        parent?: SystemAssembly;
+    });
+    protected check(call: string): void;
+    transform(kind: string, params: Record<string, unknown>): void;
+    getPlacement(): Placement;
+    getWorldPlacement(): Placement;
+    addChild(children: (Body | SystemAssembly)[], options?: {
+        keepWorld?: boolean;
+    }): void;
+    removeChild(child: Body | SystemAssembly, options?: {
+        keepWorld?: boolean;
+    }): void;
+    getChildren(): string[];
+    getParent(): string | null;
+    getBounds(): [number, number, number, number, number, number] | null;
+    dispose(): void;
+}

package/src/bodies/wire.d.ts

@@ -0,0 +1,14 @@
+import { Body } from './body.js';
+import type { BodyOptions } from './body-options.js';
+import type { SystemAssembly } from './system-assembly.js';
+export declare class Wire extends Body {
+    constructor(kind: string, params: Record<string, unknown>, options?: BodyOptions);
+    instance(options?: {
+        ogId?: string;
+        parent?: SystemAssembly;
+    }): Wire;
+    duplicate(options?: {
+        ogId?: string;
+        parent?: SystemAssembly;
+    }): Wire;
+}

package/src/constants/index.d.ts

@@ -0,0 +1,4 @@
+export * from './primitives.js';
+export * from './operations.js';
+export * from './transforms.js';
+export * from './regions.js';

package/src/constants/operations.d.ts

@@ -0,0 +1,58 @@
+export declare const OG_OPERATION_EXTRUDE: "Extrude";
+export declare const OG_OPERATION_SWEEP: "Sweep";
+export declare const OG_OPERATION_REVOLVE: "Revolve";
+export declare const OG_OPERATION_UNION: "Union";
+export declare const OG_OPERATION_SUBTRACT: "Subtract";
+export declare const OG_OPERATION_INTERSECT: "Intersect";
+export declare const OG_OPERATION_SHELL: "Shell";
+export declare const OG_OPERATION_PARAMS_EXTRUDE: (value: {
+    profile: {
+        ogId: string;
+    };
+    holes?: {
+        ogId: string;
+    }[];
+    distance: number;
+}) => {
+    profile: {
+        ogId: string;
+    };
+    holes?: {
+        ogId: string;
+    }[];
+    distance: number;
+};
+export declare const OG_OPERATION_PARAMS_SWEEP: (value: {
+    profile: {
+        ogId: string;
+    };
+    path: {
+        ogId: string;
+    };
+    caps?: boolean;
+}) => {
+    profile: {
+        ogId: string;
+    };
+    path: {
+        ogId: string;
+    };
+    caps?: boolean;
+};
+export declare const OG_OPERATION_PARAMS_REVOLVE: (value: {
+    profile: {
+        ogId: string;
+    };
+    axis?: {
+        point: [number, number];
+        direction: [number, number];
+    };
+}) => {
+    profile: {
+        ogId: string;
+    };
+    axis?: {
+        point: [number, number];
+        direction: [number, number];
+    };
+};

package/src/constants/primitives.d.ts

@@ -0,0 +1,69 @@
+import type { ArcParams, ConeParams, CylinderSectorParams, PolyhedronParams, ProfileParams, SphereParams, TorusParams, SlotPrismParams, RoundedBoxParams, PipeSegmentParams, PolysolidParams, RegularPolygonParams, SlotParams, RoundedRectangleParams } from '../dto/primitives.js';
+export declare const OG_PRIMITIVE_RECTANGLE: "Rectangle";
+export declare const OG_PRIMITIVE_CIRCLE: "Circle";
+export declare const OG_PRIMITIVE_POLYLINE: "Polyline";
+export declare const OG_PRIMITIVE_CUBOID: "Cuboid";
+export declare const OG_PRIMITIVE_CYLINDER: "Cylinder";
+export declare const OG_PRIMITIVE_CYLINDER_SECTOR: "CylinderSector";
+export declare const OG_PRIMITIVE_POLYHEDRON: "Polyhedron";
+export declare const OG_PRIMITIVE_SPHERE: "Sphere";
+export declare const OG_PRIMITIVE_CONE: "Cone";
+export declare const OG_PRIMITIVE_TORUS: "Torus";
+export declare const OG_PRIMITIVE_PROFILE: "Profile";
+export declare const OG_PRIMITIVE_ARC: "Arc";
+export declare const OG_PRIMITIVE_SLOT_PRISM: "SlotPrism";
+export declare const OG_PRIMITIVE_ROUNDED_BOX: "RoundedBox";
+export declare const OG_PRIMITIVE_PIPE_SEGMENT: "PipeSegment";
+export declare const OG_PRIMITIVE_POLYSOLID: "Polysolid";
+export declare const OG_PRIMITIVE_REGULAR_POLYGON: "RegularPolygon";
+export declare const OG_PRIMITIVE_SLOT: "Slot";
+export declare const OG_PRIMITIVE_ROUNDED_RECTANGLE: "RoundedRectangle";
+export declare const OG_PRIMITIVE_PARAMS_RECTANGLE: (value: {
+    width: number;
+    breadth: number;
+}) => {
+    width: number;
+    breadth: number;
+};
+export declare const OG_PRIMITIVE_PARAMS_CIRCLE: (value: {
+    radius: number;
+}) => {
+    radius: number;
+};
+export declare const OG_PRIMITIVE_PARAMS_POLYLINE: (value: {
+    points: [number, number, number][];
+    closed?: boolean;
+}) => {
+    points: [number, number, number][];
+    closed?: boolean;
+};
+export declare const OG_PRIMITIVE_PARAMS_CUBOID: (value: {
+    width: number;
+    height: number;
+    depth: number;
+}) => {
+    width: number;
+    height: number;
+    depth: number;
+};
+export declare const OG_PRIMITIVE_PARAMS_CYLINDER: (value: {
+    radius: number;
+    height: number;
+}) => {
+    radius: number;
+    height: number;
+};
+export declare const OG_PRIMITIVE_PARAMS_PROFILE: (value: ProfileParams) => ProfileParams;
+export declare const OG_PRIMITIVE_PARAMS_ARC: (value: ArcParams) => ArcParams;
+export declare const OG_PRIMITIVE_PARAMS_CYLINDER_SECTOR: (value: CylinderSectorParams) => CylinderSectorParams;
+export declare const OG_PRIMITIVE_PARAMS_POLYHEDRON: (value: PolyhedronParams) => PolyhedronParams;
+export declare const OG_PRIMITIVE_PARAMS_SPHERE: (value: SphereParams) => SphereParams;
+export declare const OG_PRIMITIVE_PARAMS_CONE: (value: ConeParams) => ConeParams;
+export declare const OG_PRIMITIVE_PARAMS_TORUS: (value: TorusParams) => TorusParams;
+export declare const OG_PRIMITIVE_PARAMS_SLOT_PRISM: (value: SlotPrismParams) => SlotPrismParams;
+export declare const OG_PRIMITIVE_PARAMS_ROUNDED_BOX: (value: RoundedBoxParams) => RoundedBoxParams;
+export declare const OG_PRIMITIVE_PARAMS_PIPE_SEGMENT: (value: PipeSegmentParams) => PipeSegmentParams;
+export declare const OG_PRIMITIVE_PARAMS_POLYSOLID: (value: PolysolidParams) => PolysolidParams;
+export declare const OG_PRIMITIVE_PARAMS_REGULAR_POLYGON: (value: RegularPolygonParams) => RegularPolygonParams;
+export declare const OG_PRIMITIVE_PARAMS_SLOT: (value: SlotParams) => SlotParams;
+export declare const OG_PRIMITIVE_PARAMS_ROUNDED_RECTANGLE: (value: RoundedRectangleParams) => RoundedRectangleParams;

package/src/constants/regions.d.ts

@@ -0,0 +1 @@
+export declare const OG_REGION_TOLERANCE: 0.000001;

package/src/constants/transforms.d.ts

@@ -0,0 +1,4 @@
+export declare const OG_TRANSFORM_TRANSLATE: "Translate";
+export declare const OG_TRANSFORM_ROTATE: "Rotate";
+export declare const OG_TRANSFORM_SCALE: "Scale";
+export declare const OG_TRANSFORM_PLACE: "Place";

package/src/dto/boolean-report.d.ts

@@ -0,0 +1,24 @@
+import type { FaceSource, GeometryQuality } from './brep.js';
+export type FaceMapping = {
+    source: FaceSource;
+    result_faces: number[];
+};
+export type BooleanReport = {
+    operation: 'union' | 'intersection' | 'subtraction';
+    quality: GeometryQuality;
+    contacts: [number, number, number][];
+    coincident: boolean;
+    face_mappings: FaceMapping[];
+};
+export type ShapeReport = {
+    report: BooleanReport;
+    handlers: string[];
+    revision: number;
+};
+export type OperateErrorDetails = {
+    handlers: string[];
+    attempted: string[];
+    families?: [string, string];
+    toolIndex: number;
+    ogIds: string[];
+};

package/src/dto/bounds.d.ts

@@ -0,0 +1 @@
+export type Bounds = [number, number, number, number, number, number];

package/src/dto/brep.d.ts

@@ -0,0 +1,99 @@
+export type GeometryQuality = {
+    kind: 'Analytic';
+} | {
+    kind: 'Approximate';
+    max_error: number;
+};
+export type FaceSource = {
+    entity: string;
+    body: string;
+    key: string;
+    face: number;
+};
+export type BrepVertex = {
+    id: number;
+    position: [number, number, number];
+    outgoing_halfedge: number | null;
+    tolerance: number;
+};
+export type BrepEdge = {
+    id: number;
+    geometry: unknown;
+    halfedge: number;
+    twin_halfedge: number | null;
+    tolerance: number;
+    chart_seam: boolean;
+};
+export type BrepHalfedge = {
+    id: number;
+    from: number;
+    to: number;
+    twin: number | null;
+    next: number | null;
+    prev: number | null;
+    edge: number;
+    face: number | null;
+    loop_ref: number | null;
+    wire_ref: number | null;
+    geometry_use: unknown;
+};
+export type BrepLoop = {
+    id: number;
+    start_halfedge: number;
+    face_ref: number;
+    is_hole: boolean;
+};
+export type BrepFace = {
+    id: number;
+    key: string;
+    surface: number;
+    sense: 'Forward' | 'Reverse';
+    trim: unknown;
+    shell_ref: number | null;
+    provenance: {
+        sources: FaceSource[];
+        role: 'Authored' | 'Preserved' | 'Split' | 'Cut' | 'Coincident';
+        reversed: boolean;
+    };
+};
+export type BrepWire = {
+    id: number;
+    start_halfedge: number;
+    is_closed: boolean;
+};
+export type BrepShell = {
+    id: number;
+    faces: number[];
+    is_closed: boolean;
+};
+export type Brep = {
+    schema_version: number;
+    id: string;
+    revision: number;
+    geometry: {
+        surfaces: unknown[];
+        curves: unknown[];
+        pcurves: unknown[];
+        intersections: unknown[];
+    };
+    topology: {
+        vertices: BrepVertex[];
+        edges: BrepEdge[];
+        halfedges: BrepHalfedge[];
+        loops: BrepLoop[];
+        faces: BrepFace[];
+        wires: BrepWire[];
+        shells: BrepShell[];
+    };
+    solids: {
+        outer_shell: number;
+        cavity_shells: number[];
+    }[];
+    accuracy: {
+        geometric: number;
+        intersection: number;
+        tessellation: number;
+        exchange: number;
+    };
+    quality: GeometryQuality;
+};

package/src/dto/change-set.d.ts

@@ -0,0 +1,13 @@
+export type NodeChange = {
+    ogId: string;
+    handle: number;
+    generation: number;
+    shapeId: string | null;
+    shapeRevision: number | null;
+};
+export type ChangeSet = {
+    revision: number;
+    added: NodeChange[];
+    changed: NodeChange[];
+    removed: NodeChange[];
+};

package/src/dto/creation.d.ts

@@ -0,0 +1,3 @@
+export type Creation = {
+    ogId: string;
+};

package/src/dto/display-buffers.d.ts

@@ -0,0 +1,14 @@
+export type DisplayBuffers = {
+    positions: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    faceRanges: Uint32Array;
+    outline: Float32Array;
+    edgeIds: Uint32Array;
+    smoothEdges: Uint8Array;
+    origin: Float64Array;
+    revision: number;
+    bucket: number;
+    achievedDeflection: number;
+    triangles: number;
+};

package/src/dto/events.d.ts

@@ -0,0 +1,2 @@
+export type Events = 'geometry' | 'warning' | 'error' | 'fatal';
+export type Listener = (event: unknown) => void;