nodi-modular 0.0.36 → 0.0.37

package/index.d.ts

@@ -1,11 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
 export function do_nothing_just_tell_wasm_bindgen_to_generate_types(): void;
-/**
- * Evaluation item interoperability type.
- */
-export type Item = { variant: "Bool"; data: boolean } | { variant: "String"; data: string } | { variant: "Number"; data: number } | { variant: "Domain"; data: Domain } | { variant: "Vector3"; data: Vector3<number> } | { variant: "Matrix4"; data: Matrix4<number> } | { variant: "Complex"; data: Complex<number> } | { variant: "Point3"; data: Point3<number> } | { variant: "Plane"; data: Plane } | { variant: "GeometryTransform"; data: GeometryTransformInterop } | { variant: "MeshFace"; data: MeshTriangleFace };
-
 export interface GeometryTransformInterop {
     geometry: GeometryProxy;
     transform: TransformInterop;
@@ -13,38 +8,38 @@ export interface GeometryTransformInterop {
 
 export type NodeOutput = (Map<string, Item[]> | undefined)[];
 
-export interface GroupInteropHandle {
-    objects: GeometryInteropHandleProxy[];
-}
-
 /**
- * Interop struct for node property
+ * Evaluation item interoperability type.
  */
-export interface NodePropertyInterop {
-    /**
-     * Property name
-     */
-    name: string;
-    /**
-     * Property value
-     */
-    value: NodePropertyValue;
-    /**
-     * Whether the node has input connection and the property change is disabled
-     */
-    connected?: boolean;
-    /**
-     * Whether the property is disabled in node\' inspector
-     */
-    disabled?: boolean;
+export type Item = { variant: "Bool"; data: boolean } | { variant: "String"; data: string } | { variant: "Number"; data: number } | { variant: "Domain"; data: Domain } | { variant: "Vector3"; data: Vector3<number> } | { variant: "Matrix4"; data: Matrix4<number> } | { variant: "Complex"; data: Complex<number> } | { variant: "Point3"; data: Point3<number> } | { variant: "Plane"; data: Plane } | { variant: "GeometryTransform"; data: GeometryTransformInterop } | { variant: "MeshFace"; data: MeshTriangleFace };
+
+export interface GeometrySpreadsheet {
+    points: Point3<number>[];
+    curves: CurveProxy[];
+    surfaces: SurfaceProxy[];
+    meshes: MeshInterop[];
 }
 
-export interface IndicesInteropHandle {
-    count: number;
-    indices: number;
+export interface EdgeInterop {
+    source: EdgeUnitInterop<OutputId>;
+    destination: EdgeUnitInterop<InputId>;
+    empty: boolean;
 }
 
-export type GeometryInteropHandleProxy = { variant: "Mesh"; data: MeshInteropHandle } | { variant: "Curve"; data: CurveInteropHandle } | { variant: "Group"; data: GroupInteropHandle };
+export interface EdgeUnitInterop<IO> {
+    node: NodeId;
+    io: IO;
+}
+
+export type GeometryInteropVec = GeometryInterop[];
+
+export type NodeConnectionInteropVec = NodeConnectionInterop[];
+
+export type NodePropertyInteropVec = NodePropertyInterop[];
+
+export type NodeInteropVec = NodeInterop[];
+
+export type EdgeInteropVec = EdgeInterop[];
 
 export interface DataTreeInterop {
     branches: IndexMap<string, string[]>;
@@ -54,23 +49,35 @@ export interface DataTreeFormatInterop {
     outputs: IndexMap<string, string>;
 }
 
-export interface EdgeInterop {
-    source: EdgeUnitInterop<OutputId>;
-    destination: EdgeUnitInterop<InputId>;
-    empty: boolean;
+export type NodeSectionInterop = { type: "section"; content: NodeFolderInterop } | { type: "item"; content: NodeItemInterop };
+
+export interface NodeItemInterop {
+    key: string;
+    name: string;
 }
 
-export interface EdgeUnitInterop<IO> {
-    node: NodeId;
-    io: IO;
+export type NodeFolderInterop = IndexMap<string, NodeSectionInterop>;
+
+export interface NodeMapInterop {
+    folder: NodeFolderInterop;
 }
 
-export interface MeshInteropHandle {
-    count: number;
-    vertices: number;
-    normals: number;
-    indices: IndicesInteropHandle | undefined;
-    transform: TransformInterop | undefined;
+/**
+ * Interop struct for evaluation results
+ */
+export interface EvaluationInterop {
+    /**
+     * Processed nodes in the latest evaluation
+     */
+    processedNodes: GraphNodeSet[];
+    /**
+     * Geometry identifiers in the latest evaluation
+     */
+    geometryIdentifiers: GeometryIdentifier[];
+}
+
+export interface GroupInteropHandle {
+    objects: GeometryInteropHandleProxy[];
 }
 
 export interface NodeCreationSetting {
@@ -85,6 +92,28 @@ export interface NodeCreationSetting {
     visible?: boolean;
 }
 
+/**
+ * Interop struct for node property
+ */
+export interface NodePropertyInterop {
+    /**
+     * Property name
+     */
+    name: string;
+    /**
+     * Property value
+     */
+    value: NodePropertyValue;
+    /**
+     * Whether the node has input connection and the property change is disabled
+     */
+    connected?: boolean;
+    /**
+     * Whether the property is disabled in node\' inspector
+     */
+    disabled?: boolean;
+}
+
 
 /// Manually added types due to limitations in the `wasm-bindgen` & `tsify` crates.
 export type ID<T = any> = string;
@@ -117,6 +146,36 @@ export type Transform3<T = number> = FixedLengthArray<T, 16>;
 export type Matrix4<T = number> = FixedLengthArray<FixedLengthArray<T, 4>, 4>;
 
 
+/**
+ * Options for adaptive tessellation to create geometry interoperability
+ */
+export interface AdaptiveTessellationOptions {
+    /**
+     * Whether to enable adaptive tessellation
+     */
+    enabled: boolean;
+    /**
+     * Tolerance for the normal vector: if the L2 norm of the normal vectors is below this value, the edge is considered flat
+     */
+    normTolerance: number;
+    /**
+     * Minimum number of divisions in u direction
+     */
+    minDivsU: number;
+    /**
+     * Minimum number of divisions in v direction
+     */
+    minDivsV: number;
+    /**
+     * Minimum depth for division
+     */
+    minDepth: number;
+    /**
+     * Maximum depth for division
+     */
+    maxDepth: number;
+}
+
 /**
  * Interop struct for node
  */
@@ -190,6 +249,36 @@ export interface NodeConnectionInterop {
     inputConnectionIndex: number | undefined;
 }
 
+export interface IOInterop {
+    id: string;
+    name: string;
+    accessType: AccessTypes;
+    hint: TypeHint | undefined;
+    connections: string[];
+}
+
+/**
+ * Geometry identifier
+ */
+export interface GeometryIdentifier {
+    /**
+     * Parent node ID
+     */
+    graphNodeSet?: GraphNodeSet;
+    /**
+     * Output ID that the geometry is belonged to
+     */
+    outputId: OutputId;
+    /**
+     * Geometry ID
+     */
+    geometryId: ID<GeometryProxy>;
+    /**
+     * Transform matrix in interop format
+     */
+    transform: TransformInterop;
+}
+
 export interface PointListHandleUnit {
     count: number;
     points: number;
@@ -214,190 +303,87 @@ export interface VectorDisplayHandle {
 
 export type DisplayProxyHandle = { variant: "Vector"; data: VectorDisplayHandle } | { variant: "PointList"; data: PointListDisplayHandle };
 
-export interface GeometrySpreadsheet {
-    points: Point3<number>[];
-    curves: CurveProxy[];
-    surfaces: SurfaceProxy[];
-    meshes: MeshInterop[];
+export type GeometryInteropHandleProxy = { variant: "Mesh"; data: MeshInteropHandle } | { variant: "Curve"; data: CurveInteropHandle } | { variant: "Group"; data: GroupInteropHandle };
+
+export interface SubGraphIdSet {
+    subGraphId: SubGraphId;
+    instanceId: SubGraphInstanceId;
 }
 
 /**
- * Options for adaptive tessellation to create geometry interoperability
+ * Defines the dynamics of an IO parameter.
  */
-export interface AdaptiveTessellationOptions {
-    /**
-     * Whether to enable adaptive tessellation
-     */
-    enabled: boolean;
-    /**
-     * Tolerance for the normal vector: if the L2 norm of the normal vectors is below this value, the edge is considered flat
-     */
-    normTolerance: number;
-    /**
-     * Minimum number of divisions in u direction
-     */
-    minDivsU: number;
-    /**
-     * Minimum number of divisions in v direction
-     */
-    minDivsV: number;
-    /**
-     * Minimum depth for division
-     */
-    minDepth: number;
-    /**
-     * Maximum depth for division
-     */
-    maxDepth: number;
+export interface IOVariables {
+    minCount: number;
+    maxCount: number;
+    defaultCount: number;
+    offset: number;
+    editable: boolean;
 }
 
 /**
- * Interop struct for transform
- * Represents a 4x4 matrix as a 16-element array
+ * A set of node id and instance id
  */
-export type TransformInterop = number[];
-
-export type GeometryInteropVec = GeometryInterop[];
-
-export type NodeConnectionInteropVec = NodeConnectionInterop[];
+export interface GraphNodeSet {
+    subGraphIdSet: SubGraphIdSet | undefined;
+    nodeId: NodeId;
+}
 
-export type NodePropertyInteropVec = NodePropertyInterop[];
+export type AccessTypes = "Item" | "List" | "Tree";
 
-export type NodeInteropVec = NodeInterop[];
+/**
+ * A parameter for an input or output of a node.
+ */
+export interface IOParameter<T, U> {
+    id: T;
+    name: string;
+    access_type: AccessTypes;
+    hint?: TypeHint;
+    connections: U[];
+}
 
-export type EdgeInteropVec = EdgeInterop[];
+export type TypeHint = Internal;
 
-export interface IOInterop {
-    id: string;
-    name: string;
-    accessType: AccessTypes;
-    hint: TypeHint | undefined;
-    connections: string[];
+export interface IOManager<T, U> {
+    parameters: IOParameter<T, U>[];
 }
 
-/**
- * Interop struct for evaluation results
- */
-export interface EvaluationInterop {
-    /**
-     * Processed nodes in the latest evaluation
-     */
-    processedNodes: GraphNodeSet[];
-    /**
-     * Geometry identifiers in the latest evaluation
-     */
-    geometryIdentifiers: GeometryIdentifier[];
-}
-
-/**
- * Curve interop handle for wasm interop
- * stride = 3 (x, y, z)
- */
-export interface CurveInteropHandle {
-    count: number;
-    vertices: number;
-    transform: TransformInterop | undefined;
-}
-
-export type NodeSectionInterop = { type: "section"; content: NodeFolderInterop } | { type: "item"; content: NodeItemInterop };
+export type GraphMappingTypes = "None" | "Bezier" | "Linear" | "Sine";
 
-export interface NodeItemInterop {
-    key: string;
-    name: string;
+export interface Connection {
+    source: NodeParameter<OutputId>;
+    destination: NodeParameter<InputId>;
 }
 
-export type NodeFolderInterop = IndexMap<string, NodeSectionInterop>;
-
-export interface NodeMapInterop {
-    folder: NodeFolderInterop;
+export interface NodeParameter<T> {
+    nodeId: NodeId;
+    parameterId: T;
+    parameterIndex: number;
 }
 
 /**
- * Geometry identifier
+ * A sub graph is a graph that is a part of a larger graph
  */
-export interface GeometryIdentifier {
-    /**
-     * Parent node ID
-     */
-    graphNodeSet?: GraphNodeSet;
+export interface SubGraph<T, U> {
     /**
-     * Output ID that the geometry is belonged to
+     * The id of the sub graph
      */
-    outputId: OutputId;
+    id: SubGraphId;
     /**
-     * Geometry ID
+     * The graph of the sub graph
      */
-    geometryId: ID<GeometryProxy>;
+    graph: Graph<T, U>;
     /**
-     * Transform matrix in interop format
+     * The instances of the sub graph
      */
-    transform: TransformInterop;
-}
-
-export interface SubGraphIdSet {
-    subGraphId: SubGraphId;
-    instanceId: SubGraphInstanceId;
-}
-
-export interface NodePropertyCategoryValue {
-    candidates: IndexMap<string, number>;
-    selected: number;
-}
-
-export interface NodePropertyRangeValue {
-    value: number;
-    min: number | undefined;
-    max: number | undefined;
-    step: number | undefined;
-}
-
-export type NodePropertyValue = { type: "Number"; content: number } | { type: "Range"; content: NodePropertyRangeValue } | { type: "Range2d"; content: [NodePropertyRangeValue, NodePropertyRangeValue] } | { type: "String"; content: string } | { type: "Bool"; content: boolean } | { type: "NumberVector"; content: number[] } | { type: "Category"; content: NodePropertyCategoryValue } | { type: "Vector2d"; content: [number, number] } | { type: "Vector3d"; content: [number, number, number] } | { type: "Point2d"; content: [number, number] } | { type: "Point3d"; content: [number, number, number] } | { type: "Points2d"; content: [number, number][] } | { type: "Buffer"; content: number[] };
-
-/**
- * Defines the dynamics of an IO parameter.
- */
-export interface IOVariables {
-    minCount: number;
-    maxCount: number;
-    defaultCount: number;
-    offset: number;
-    editable: boolean;
-}
-
-/**
- * A set of node id and instance id
- */
-export interface GraphNodeSet {
-    subGraphIdSet: SubGraphIdSet | undefined;
-    nodeId: NodeId;
-}
-
-export type AccessTypes = "Item" | "List" | "Tree";
-
-export interface Connection {
-    source: NodeParameter<OutputId>;
-    destination: NodeParameter<InputId>;
-}
-
-export interface NodeParameter<T> {
-    nodeId: NodeId;
-    parameterId: T;
-    parameterIndex: number;
-}
-
-export interface ConnectedComponentNode {
-    sources: NodeId[];
-    destinations: NodeId[];
+    instances: SubGraphInstanceId[];
 }
 
-export interface ConnectedComponents<T, U> {
-    nodes: IndexMap<NodeId, ConnectedComponentNode<T, U>>;
+export interface Prune<T, U> {
+    connectedComponents: ConnectedComponents<T, U>[];
+    bypass: Connection[] | undefined;
 }
 
-export type TypeHint = Internal;
-
-export type GraphMappingTypes = "None" | "Bezier" | "Linear" | "Sine";
-
 export interface Node<T> {
     id: NodeId;
     name: string;
@@ -413,23 +399,20 @@ export type OutputIOManager = IOManager<OutputId, InputId>;
 
 export type InputIOManager = IOManager<InputId, OutputId>;
 
-/**
- * A parameter for an input or output of a node.
- */
-export interface IOParameter<T, U> {
-    id: T;
-    name: string;
-    access_type: AccessTypes;
-    hint?: TypeHint;
-    connections: U[];
+export interface NodePropertyCategoryValue {
+    candidates: IndexMap<string, number>;
+    selected: number;
 }
 
-export type GraphVariant = "Root" | { SubGraph: SubGraphId };
-
-export interface IOManager<T, U> {
-    parameters: IOParameter<T, U>[];
+export interface NodePropertyRangeValue {
+    value: number;
+    min: number | undefined;
+    max: number | undefined;
+    step: number | undefined;
 }
 
+export type NodePropertyValue = { type: "Number"; content: number } | { type: "Range"; content: NodePropertyRangeValue } | { type: "Range2d"; content: [NodePropertyRangeValue, NodePropertyRangeValue] } | { type: "String"; content: string } | { type: "Bool"; content: boolean } | { type: "NumberVector"; content: number[] } | { type: "Category"; content: NodePropertyCategoryValue } | { type: "Vector2d"; content: [number, number] } | { type: "Vector3d"; content: [number, number, number] } | { type: "Point2d"; content: [number, number] } | { type: "Point3d"; content: [number, number, number] } | { type: "Points2d"; content: [number, number][] } | { type: "Buffer"; content: number[] };
+
 /**
  * Graph structure
  */
@@ -444,29 +427,17 @@ export interface Graph<T, U> {
     sub_graphs?: IndexMap<SubGraphId, SubGraph<T, U>>;
 }
 
-/**
- * A sub graph is a graph that is a part of a larger graph
- */
-export interface SubGraph<T, U> {
-    /**
-     * The id of the sub graph
-     */
-    id: SubGraphId;
-    /**
-     * The graph of the sub graph
-     */
-    graph: Graph<T, U>;
-    /**
-     * The instances of the sub graph
-     */
-    instances: SubGraphInstanceId[];
+export interface ConnectedComponentNode {
+    sources: NodeId[];
+    destinations: NodeId[];
 }
 
-export interface Prune<T, U> {
-    connectedComponents: ConnectedComponents<T, U>[];
-    bypass: Connection[] | undefined;
+export interface ConnectedComponents<T, U> {
+    nodes: IndexMap<NodeId, ConnectedComponentNode<T, U>>;
 }
 
+export type GraphVariant = "Root" | { SubGraph: SubGraphId };
+
 
 export type LineCurve3D = {
     a: Point3;
@@ -474,6 +445,13 @@ export type LineCurve3D = {
 };
 
 
+export type NurbsCurve3D<T = number> = {
+    control_points: Point4<T>[];
+    knots: T[];
+    degree: T;
+};
+
+
 export type PolylineCurve2D = {
     points: Point2[];
 };
@@ -500,6 +478,10 @@ export interface MeshInterop {
      * Normals of the mesh
      */
     normals: [number, number, number][];
+    /**
+     * Colors of the mesh
+     */
+    colors?: [number, number, number][];
     /**
      * UV coordinates of the mesh
      */
@@ -514,35 +496,27 @@ export interface MeshInterop {
     transform?: Transform3<number>;
 }
 
-/**
- * A collection of geometry objects
- */
-export type Group = GeometryTransform[];
+export type NurbsCurve = NurbsCurve3D<number>;
 
-/**
- * Proxy for various surface types
- */
-export type SurfaceProxy = { variant: "Circular"; data: CircularSurface } | { variant: "Triangle"; data: TriangleSurface } | { variant: "Plane"; data: PlaneSurface } | { variant: "NURBS"; data: NurbsSurface } | { variant: "Trimmed"; data: TrimmedSurface };
+export interface Domain {
+    min: number;
+    max: number;
+}
 
 /**
- * A circular surface
+ * Interop struct for point cloud data
  */
-export interface CircularSurface {
+export interface PointCloudInterop {
     /**
-     * The base plane of the circle
+     * Vertices of the point cloud
      */
-    plane: Plane;
+    vertices: [number, number, number][];
     /**
-     * The radius of the circle
+     * Transform matrix of the point cloud
      */
-    radius: number;
+    transform: Transform3<number>;
 }
 
-/**
- * Interop proxy for various geometry types
- */
-export type GeometryInterop = { variant: "Mesh"; data: MeshInterop } | { variant: "Curve"; data: CurveInterop } | { variant: "Point"; data: PointCloudInterop } | { variant: "Plane"; data: Plane } | { variant: "Group"; data: GeometryInterop[] };
-
 /**
  * Plane representation with origin, normal, x axis, and y axis
  */
@@ -565,6 +539,20 @@ export interface Plane {
     yAxis: Vector3<number>;
 }
 
+/**
+ * A collection of geometry objects
+ */
+export type Group = GeometryTransform[];
+
+/**
+ * A face of a mesh with three vertices
+ */
+export interface MeshTriangleFace {
+    a: number;
+    b: number;
+    c: number;
+}
+
 /**
  * A geometry object with a transformation
  */
@@ -579,32 +567,8 @@ export interface GeometryTransform {
     transform: Transform3<number>;
 }
 
-/**
- * Interop struct for point cloud data
- */
-export interface PointCloudInterop {
-    /**
-     * Vertices of the point cloud
-     */
-    vertices: [number, number, number][];
-    /**
-     * Transform matrix of the point cloud
-     */
-    transform: Transform3<number>;
-}
-
-/**
- * Geometry proxy for various geometry types
- */
-export type GeometryProxy = { variant: "Curve"; data: CurveProxy } | { variant: "Surface"; data: SurfaceProxy } | { variant: "Brep"; data: Brep } | { variant: "Mesh"; data: Mesh } | { variant: "BBox"; data: OrientedBox } | { variant: "Group"; data: Group };
-
 export type PolyCurve = CompoundCurve<number, U4>;
 
-/**
- * Proxy for various curve types
- */
-export type CurveProxy = { variant: "Line"; data: LineCurve3D } | { variant: "Arc"; data: ArcCurve } | { variant: "Circle"; data: CircleCurve } | { variant: "Ellipse"; data: EllipseCurve } | { variant: "Rectangle"; data: RectangleCurve } | { variant: "Polyline"; data: PolylineCurve3D } | { variant: "NURBS"; data: NurbsCurve } | { variant: "Poly"; data: PolyCurve };
-
 
 export type NurbsSurface3D<T = number> = {
     control_points: Point4<T>[][];
@@ -614,6 +578,20 @@ export type NurbsSurface3D<T = number> = {
     v_degree: T;
 };
 
+/**
+ * Interop struct for curve data
+ */
+export interface CurveInterop {
+    /**
+     * Vertices of the curve
+     */
+    vertices: [number, number, number][];
+    /**
+     * Transform matrix of the curve
+     */
+    transform: Transform3<number> | undefined;
+}
+
 /**
  * An oriented box in 3D space
  */
@@ -629,50 +607,91 @@ export interface OrientedBox {
 }
 
 /**
- * A NURBS surface container
- */
-export type NurbsSurface = NurbsSurface3D<number>;
-
-/**
- * A rectangle curve in 3D space
+ * Mesh representation with vertices, normals, uv, and index
  */
-export interface RectangleCurve {
+export interface Mesh {
     /**
-     * The base plane of the rectangle
+     * Vertices of the mesh
      */
-    plane: Plane;
+    vertices: Point3<number>[];
     /**
-     * The domain of the rectangle in the plane x axis
+     * Normals of the mesh
      */
-    x: Domain;
+    normals: Vector3<number>[] | undefined;
     /**
-     * The domain of the rectangle in the plane y axis
+     * UV coordinates of the mesh
      */
-    y: Domain;
+    uv: Vector2<number>[] | undefined;
+    /**
+     * Colors of the mesh
+     */
+    colors: Vector3<number>[] | undefined;
+    /**
+     * Index of the mesh
+     */
+    index: [number, number, number][];
 }
 
 /**
- * A ellipse curve in 3D space
+ * A surface defined by three points
  */
-export interface EllipseCurve {
+export type TriangleSurface = Triangle3D;
+
+/**
+ * A NURBS surface container
+ */
+export type NurbsSurface = NurbsSurface3D<number>;
+
+export interface MeshInteropHandle {
+    count: number;
+    vertices: number;
+    normals: number;
+    indices: IndicesInteropHandle | undefined;
+    transform: TransformInterop | undefined;
+}
+
+export interface IndicesInteropHandle {
+    count: number;
+    indices: number;
+}
+
+/**
+ * Curve interop handle for wasm interop
+ * stride = 3 (x, y, z)
+ */
+export interface CurveInteropHandle {
+    count: number;
+    vertices: number;
+    transform: TransformInterop | undefined;
+}
+
+/**
+ * Interop proxy for various geometry types
+ */
+export type GeometryInterop = { variant: "Mesh"; data: MeshInterop } | { variant: "Curve"; data: CurveInterop } | { variant: "Point"; data: PointCloudInterop } | { variant: "Plane"; data: Plane } | { variant: "Group"; data: GeometryInterop[] };
+
+/**
+ * A surface defined by a plane and two domains in x and y directions
+ */
+export interface PlaneSurface {
     /**
-     * The base plane of the ellipse
+     * The base plane of the surface
      */
     plane: Plane;
     /**
-     * The x radius of the ellipse
+     * The domain in x direction
      */
-    xRadius: number;
+    x: Domain;
     /**
-     * The y radius of the ellipse
+     * The domain in y direction
      */
-    yRadius: number;
+    y: Domain;
 }
 
 /**
- * A circle curve in 3D space
+ * A circular surface
  */
-export interface CircleCurve {
+export interface CircularSurface {
     /**
      * The base plane of the circle
      */
@@ -684,119 +703,143 @@ export interface CircleCurve {
 }
 
 /**
- * An arc curve in 3D space
+ * A surface defined by a base surface and trimming curves
+ *
+ * The trimming curves are defined in the parameter space (2D) of the base surface.
+ * - exterior: Optional outer boundary curve in parameter space
+ * - interiors: Interior holes in parameter space
  */
-export interface ArcCurve {
+export interface TrimmedSurface {
+    baseSurface: SurfaceProxy;
+    exterior: CompoundCurve2D<number> | undefined;
+    interiors: CompoundCurve2D<number>[];
+}
+
+/**
+ * A surface defined by a plane and two domains in x and y directions
+ */
+export interface TorusSurface {
     /**
-     * The base plane of the arc
+     * The base plane of the surface
      */
     plane: Plane;
     /**
-     * The start angle of the arc
+     * The major radius of the torus
      */
-    startAngle: number;
+    majorRadius: number;
     /**
-     * The end angle of the arc
+     * The minor radius of the torus
      */
-    endAngle: number;
+    minorRadius: number;
     /**
-     * The radius of the arc
+     * The domain in u direction
      */
-    radius: number;
+    uDomain: Domain;
+    /**
+     * The domain in v direction
+     */
+    vDomain: Domain;
 }
 
-
-export type BoundingBox3D = {
-    min: Vector3;
-    max: Vector3;
-};
-
-export interface Domain {
-    min: number;
-    max: number;
+/**
+ * A circle curve in 3D space
+ */
+export interface CircleCurve {
+    /**
+     * The base plane of the circle
+     */
+    plane: Plane;
+    /**
+     * The radius of the circle
+     */
+    radius: number;
 }
 
 /**
- * A face of a mesh with three vertices
+ * Interop struct for transform
+ * Represents a 4x4 matrix as a 16-element array
  */
-export interface MeshTriangleFace {
-    a: number;
-    b: number;
-    c: number;
-}
+export type TransformInterop = number[];
 
+/**
+ * Geometry proxy for various geometry types
+ */
+export type GeometryProxy = { variant: "Curve"; data: CurveProxy } | { variant: "Surface"; data: SurfaceProxy } | { variant: "Brep"; data: Brep } | { variant: "Mesh"; data: Mesh } | { variant: "BBox"; data: OrientedBox } | { variant: "Group"; data: Group };
 
-export type NurbsCurve3D<T = number> = {
-    control_points: Point4<T>[];
-    knots: T[];
-    degree: T;
-};
+/**
+ * Proxy for various surface types
+ */
+export type SurfaceProxy = { variant: "Circular"; data: CircularSurface } | { variant: "Triangle"; data: TriangleSurface } | { variant: "Plane"; data: PlaneSurface } | { variant: "Torus"; data: TorusSurface } | { variant: "NURBS"; data: NurbsSurface } | { variant: "Trimmed"; data: TrimmedSurface };
 
 /**
- * Interop struct for curve data
+ * A rectangle curve in 3D space
  */
-export interface CurveInterop {
+export interface RectangleCurve {
     /**
-     * Vertices of the curve
+     * The base plane of the rectangle
      */
-    vertices: [number, number, number][];
+    plane: Plane;
     /**
-     * Transform matrix of the curve
+     * The domain of the rectangle in the plane x axis
      */
-    transform: Transform3<number> | undefined;
+    x: Domain;
+    /**
+     * The domain of the rectangle in the plane y axis
+     */
+    y: Domain;
 }
 
 /**
- * Mesh representation with vertices, normals, uv, and index
+ * A ellipse curve in 3D space
  */
-export interface Mesh {
-    /**
-     * Vertices of the mesh
-     */
-    vertices: Point3<number>[];
-    /**
-     * Normals of the mesh
-     */
-    normals: Vector3<number>[] | undefined;
+export interface EllipseCurve {
     /**
-     * UV coordinates of the mesh
+     * The base plane of the ellipse
      */
-    uv: Vector2<number>[] | undefined;
+    plane: Plane;
     /**
-     * Colors of the mesh
+     * The x radius of the ellipse
      */
-    colors: Vector3<number>[] | undefined;
+    xRadius: number;
     /**
-     * Index of the mesh
+     * The y radius of the ellipse
      */
-    index: [number, number, number][];
+    yRadius: number;
 }
 
 /**
- * A surface defined by three points
+ * Proxy for various curve types
  */
-export type TriangleSurface = Triangle3D;
+export type CurveProxy = { variant: "Line"; data: LineCurve3D } | { variant: "Arc"; data: ArcCurve } | { variant: "Circle"; data: CircleCurve } | { variant: "Ellipse"; data: EllipseCurve } | { variant: "Rectangle"; data: RectangleCurve } | { variant: "Polyline"; data: PolylineCurve3D } | { variant: "NURBS"; data: NurbsCurve } | { variant: "Poly"; data: PolyCurve };
+
+
+export type BoundingBox3D = {
+    min: Vector3;
+    max: Vector3;
+};
 
 /**
- * A surface defined by a plane and two domains in x and y directions
+ * An arc curve in 3D space
  */
-export interface PlaneSurface {
+export interface ArcCurve {
     /**
-     * The base plane of the surface
+     * The base plane of the arc
      */
     plane: Plane;
     /**
-     * The domain in x direction
+     * The start angle of the arc
      */
-    x: Domain;
+    startAngle: number;
     /**
-     * The domain in y direction
+     * The end angle of the arc
      */
-    y: Domain;
+    endAngle: number;
+    /**
+     * The radius of the arc
+     */
+    radius: number;
 }
 
-export type NurbsCurve = NurbsCurve3D<number>;
-
 /**
  * Modular structure with a graph handle
  */
@@ -867,17 +910,17 @@ export interface InitOutput {
   readonly modular_findGeometryInteropById: (a: number, b: any) => any;
   readonly modular_updateTessellationOptions: (a: number, b: number) => void;
   readonly do_nothing_just_tell_wasm_bindgen_to_generate_types: () => void;
+  readonly wasm_bindgen__convert__closures_____invoke__hffd4dd448f07753e: (a: number, b: number, c: any) => void;
+  readonly wasm_bindgen__closure__destroy__h1033e34e643c979e: (a: number, b: number) => void;
+  readonly wasm_bindgen__convert__closures_____invoke__h963e2c009efa9d83: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;
   readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_export_4: WebAssembly.Table;
-  readonly __wbindgen_export_5: WebAssembly.Table;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __externref_drop_slice: (a: number, b: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly closure964_externref_shim: (a: number, b: number, c: any) => void;
-  readonly closure3977_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }