@snaptrude/plugin-core 0.7.1 → 0.9.0

package/dist/api/core/geom/create/index.d.ts

@@ -1,6 +1,6 @@
 import * as z from "zod";
 import { PluginApiReturn } from "../../../../types";
-import { Vec3Handle, LineHandle, ArcHandle, CircleHandle, CurveHandle, ProfileHandle, ContourHandle } from "../../../../handles";
+import { Vec3Handle, LineHandle, ArcHandle, CircleHandle, CurveHandle, ProfileHandle, ContourHandle, BrepHandle, Vec3Components } from "../../../../handles";
 /**
  * Curve creation — construct new geometric curves from point handles (all-handle
  * model, §11).
@@ -152,6 +152,243 @@ export declare abstract class PluginGeomCreateApi {
      * ```
      */
     abstract contourFromProfiles(outer: ProfileHandle, holes?: ProfileHandle[]): PluginApiReturn<ContourHandle>;
+    /**
+     * Create a closed solid **B-rep** from explicit face loops. Host API call —
+     * returns a {@linkcode BrepHandle}. Faces are plain arrays of `{x, y, z}`
+     * point components, NOT point handles (bulk-data precedent:
+     * `design.query.geometry.getTriangulatedMeshes`), in raw Babylon units.
+     *
+     * Each face is one planar loop of at least 3 points; at least 4 faces are
+     * required. Loops may be authored in any consistent winding — the host
+     * validates edge coherence (every edge shared by exactly two faces, in
+     * opposite directions) and fixes the global orientation so faces point
+     * outward. Faces must be planar and the solid must be closed; holes in faces
+     * are not supported (v1).
+     *
+     * Inspect the result via `core.geom.query.brep.*`, or commit it to the scene
+     * with `design.create.massFromBrep`.
+     *
+     * @param faces Face loops — each an ordered array of `{x, y, z}` points (≥3 points per face, ≥4 faces)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws if a face is degenerate or non-planar, an edge is not shared by
+     *   exactly two faces (open shell, non-manifold, or inconsistent winding), or
+     *   the faces do not form a valid closed solid
+     *
+     * @examplePrompt Create a brep from faces
+     * @examplePrompt Build a custom solid from a set of faces
+     * @examplePrompt Make a pyramid from triangular faces
+     *
+     * # Example
+     * ```ts
+     * // A pyramid: square base + 4 triangular sides
+     * const apex = { x: 0, y: 4, z: 0 }
+     * const a = { x: -2, y: 0, z: -2 }
+     * const b = { x: 2, y: 0, z: -2 }
+     * const c = { x: 2, y: 0, z: 2 }
+     * const d = { x: -2, y: 0, z: 2 }
+     * const brep = await snaptrude.core.geom.create.brepFromFaces([
+     *   [a, d, c, b], // base
+     *   [a, b, apex],
+     *   [b, c, apex],
+     *   [c, d, apex],
+     *   [d, a, apex],
+     * ])
+     * const faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 5
+     * ```
+     */
+    abstract brepFromFaces(faces: Vec3Components[][]): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a closed solid **B-rep** by extruding a contour along a direction.
+     * Host API call — returns a {@linkcode BrepHandle}. The direction is
+     * normalised by the host, so `amount` is the extrusion distance in raw
+     * Babylon units (negative extrudes the opposite way). The contour is copied —
+     * the input handle is never mutated. Holes and arc/circle profiles extrude
+     * natively (a circle profile yields a cylinder).
+     *
+     * Inspect the result via `core.geom.query.brep.*`, or commit it to the scene
+     * with `design.create.massFromBrep`.
+     *
+     * @param contour The cross-section to extrude (outer profile + optional holes)
+     * @param direction Extrusion direction as plain `{x, y, z}` components (non-zero, normalised by the host)
+     * @param amount Extrusion distance (non-zero; negative extrudes opposite to `direction`)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws if the extrusion is degenerate (zero amount, zero direction, or a
+     *   direction lying in the contour plane) or the contour cannot be extruded
+     *   into a valid solid
+     *
+     * @examplePrompt Extrude this profile 3 metres up
+     * @examplePrompt Make a solid by extruding this outline
+     * @examplePrompt Create a cylinder from a circle profile
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const brep = await snaptrude.core.geom.create.brepFromExtrusion(contour, { x: 0, y: 1, z: 0 }, 3)
+     * const faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6
+     * ```
+     */
+    abstract brepFromExtrusion(contour: ContourHandle, direction: Vec3Components, amount: number): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a closed solid **B-rep** by lofting between a bottom and a top
+     * contour. Host API call — returns a {@linkcode BrepHandle}. Both contours
+     * must have the same number of edges (and matching hole counts); side faces
+     * connect corresponding edges by authored index. Corresponding edges must
+     * stay coplanar — a twisted loft would produce non-planar side faces and is
+     * rejected. The contours are copied — the input handles are never mutated.
+     *
+     * Inspect the result via `core.geom.query.brep.*`, or commit it to the scene
+     * with `design.create.massFromBrep`.
+     *
+     * @param bottomContour The bottom cross-section
+     * @param topContour The top cross-section (same edge and hole counts as the bottom)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws if the contours are coincident, their edge or hole counts differ,
+     *   a side face between corresponding edges would be non-planar, or the
+     *   contours cannot be lofted into a valid solid
+     *
+     * @examplePrompt Make a tapered tower from these two outlines
+     * @examplePrompt Loft between a large base and a smaller top
+     * @examplePrompt Create a frustum from two squares
+     *
+     * # Example
+     * ```ts
+     * // A square frustum: 4m base lofted to a 2m top, 3m up
+     * const base = await snaptrude.core.geom.create.profileRect(4, 4)
+     * const top = await snaptrude.core.geom.create.profileRect(2, 2, await snaptrude.core.math.vec3.new(0, 3, 0))
+     * const brep = await snaptrude.core.geom.create.brepFromLoft(
+     *   await snaptrude.core.geom.create.contourFromProfile(base),
+     *   await snaptrude.core.geom.create.contourFromProfile(top),
+     * )
+     * const faceCount = await snaptrude.core.geom.query.brep.getFaceCount(brep) // 6
+     * ```
+     */
+    abstract brepFromLoft(bottomContour: ContourHandle, topContour: ContourHandle): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a closed solid **B-rep** from indexed mesh data: a vertex position
+     * array plus face loops of indices into it. Host API call — returns a
+     * {@linkcode BrepHandle}. The indexed form of
+     * {@linkcode PluginGeomCreateApi.brepFromFaces} — same validation (planar
+     * faces, closed manifold solid, every edge shared by exactly two faces) after
+     * the indices are expanded to point loops.
+     *
+     * Inspect the result via `core.geom.query.brep.*`, or commit it to the scene
+     * with `design.create.massFromBrep`.
+     *
+     * @param positions Vertex positions as plain `{x, y, z}` components (≥4)
+     * @param faces Face loops — each an ordered array of indices into `positions` (≥3 indices per face, ≥4 faces)
+     * @returns The new solid as a {@linkcode BrepHandle}
+     * @throws if an index is not an integer within `positions` bounds, a face is
+     *   degenerate or non-planar, or the faces do not form a valid closed solid
+     *
+     * @examplePrompt Create a brep from mesh vertices and indices
+     * @examplePrompt Turn this indexed mesh into a solid
+     * @examplePrompt Build a solid from vertex positions and face indices
+     *
+     * # Example
+     * ```ts
+     * // A tetrahedron from 4 vertices and 4 triangular faces
+     * const positions = [
+     *   { x: 0, y: 0, z: 0 },
+     *   { x: 4, y: 0, z: 0 },
+     *   { x: 2, y: 0, z: 4 },
+     *   { x: 2, y: 3, z: 1.5 },
+     * ]
+     * const brep = await snaptrude.core.geom.create.brepFromMesh(positions, [
+     *   [0, 2, 1], // base
+     *   [0, 1, 3],
+     *   [1, 2, 3],
+     *   [2, 0, 3],
+     * ])
+     * const vertexCount = await snaptrude.core.geom.query.brep.getVertexCount(brep) // 4
+     * ```
+     */
+    abstract brepFromMesh(positions: Vec3Components[], faces: number[][]): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a closed solid **B-rep** as the boolean **union** of two breps
+     * (`a ∪ b`). Host API call — returns a new {@linkcode BrepHandle}. Inputs are
+     * read-only and may be authored breps (any `core.geom.create` brep
+     * constructor) or scene-derived breps from `design.query.geometry.getBrep`;
+     * coordinates are combined as-is, so both inputs must share a frame. The
+     * result must be a single solid — disjoint inputs are rejected.
+     *
+     * The first boolean call loads the OpenCascade geometry kernel (a wasm of
+     * tens of MB — expect a pause of seconds); subsequent calls are fast.
+     *
+     * @param a First solid
+     * @param b Second solid
+     * @returns The union as a new {@linkcode BrepHandle}
+     * @throws if the inputs do not overlap or touch (the union would be disjoint
+     *   solids) or the result cannot be built as a valid single solid
+     *
+     * @examplePrompt Union these two solids
+     * @examplePrompt Merge these breps into one mass
+     * @examplePrompt Combine the tower and the podium into a single solid
+     *
+     * # Example
+     * ```ts
+     * const a = await snaptrude.core.geom.create.brepFromExtrusion(baseContour, { x: 0, y: 1, z: 0 }, 3)
+     * const b = await snaptrude.core.geom.create.brepFromExtrusion(overlappingContour, { x: 0, y: 1, z: 0 }, 5)
+     * const merged = await snaptrude.core.geom.create.brepFromUnion(a, b)
+     * ```
+     */
+    abstract brepFromUnion(a: BrepHandle, b: BrepHandle): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a closed solid **B-rep** as the boolean **subtraction** of two
+     * breps: **`a` minus `b`** — `b` is cut away from `a`. Host API call —
+     * returns a new {@linkcode BrepHandle}. Argument order matters:
+     * `brepFromSubtraction(a, b)` removes `b`'s volume from `a`. Inputs are
+     * read-only and may be authored or scene-derived breps (see
+     * {@linkcode PluginGeomCreateApi.brepFromUnion}); coordinates are combined
+     * as-is.
+     *
+     * The first boolean call loads the OpenCascade geometry kernel (a wasm of
+     * tens of MB — expect a pause of seconds); subsequent calls are fast.
+     *
+     * @param a The solid to subtract from
+     * @param b The solid to remove from `a`
+     * @returns `a` minus `b` as a new {@linkcode BrepHandle}
+     * @throws if `b` consumes `a` entirely (empty result), the result splits into
+     *   disjoint solids, or it cannot be built as a valid single solid
+     *
+     * @examplePrompt Subtract the courtyard from the building mass
+     * @examplePrompt Cut this solid out of that one
+     * @examplePrompt Punch a hole through the slab with this box
+     *
+     * # Example
+     * ```ts
+     * // buildingBrep minus courtyardBrep — order matters
+     * const carved = await snaptrude.core.geom.create.brepFromSubtraction(buildingBrep, courtyardBrep)
+     * ```
+     */
+    abstract brepFromSubtraction(a: BrepHandle, b: BrepHandle): PluginApiReturn<BrepHandle>;
+    /**
+     * Create a closed solid **B-rep** as the boolean **intersection** of two
+     * breps (`a ∩ b` — the shared volume only). Host API call — returns a new
+     * {@linkcode BrepHandle}. Inputs are read-only and may be authored or
+     * scene-derived breps (see {@linkcode PluginGeomCreateApi.brepFromUnion});
+     * coordinates are combined as-is.
+     *
+     * The first boolean call loads the OpenCascade geometry kernel (a wasm of
+     * tens of MB — expect a pause of seconds); subsequent calls are fast.
+     *
+     * @param a First solid
+     * @param b Second solid
+     * @returns The shared volume as a new {@linkcode BrepHandle}
+     * @throws if the inputs do not overlap (empty intersection), the result
+     *   splits into disjoint solids, or it cannot be built as a valid single
+     *   solid
+     *
+     * @examplePrompt Keep only the overlap of these two solids
+     * @examplePrompt Intersect these two masses
+     * @examplePrompt Clip the tower to the zoning envelope
+     *
+     * # Example
+     * ```ts
+     * const overlap = await snaptrude.core.geom.create.brepFromIntersection(towerBrep, envelopeBrep)
+     * ```
+     */
+    abstract brepFromIntersection(a: BrepHandle, b: BrepHandle): PluginApiReturn<BrepHandle>;
 }
 /**
  * Arguments for {@linkcode PluginGeomCreateApi.line}.
@@ -162,8 +399,8 @@ export declare abstract class PluginGeomCreateApi {
  * | `endPoint` | {@linkcode Vec3Handle} | End point of the line segment |
  */
 export declare const PluginGeomCreateLineArgs: z.ZodObject<{
-    startPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
-    endPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    startPoint: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    endPoint: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
 }, z.core.$strip>;
 export type PluginGeomCreateLineArgs = z.infer<typeof PluginGeomCreateLineArgs>;
 /**
@@ -177,10 +414,10 @@ export type PluginGeomCreateLineArgs = z.infer<typeof PluginGeomCreateLineArgs>;
  * | `axis` | {@linkcode Vec3Handle} | Axis direction of the arc |
  */
 export declare const PluginGeomCreateArcArgs: z.ZodObject<{
-    startPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
-    endPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
-    centrePoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
-    axis: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    startPoint: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    endPoint: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    centrePoint: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    axis: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
 }, z.core.$strip>;
 export type PluginGeomCreateArcArgs = z.infer<typeof PluginGeomCreateArcArgs>;
 /**
@@ -193,8 +430,8 @@ export type PluginGeomCreateArcArgs = z.infer<typeof PluginGeomCreateArcArgs>;
  * | `radius` | `number` | Radius of the circle |
  */
 export declare const PluginGeomCreateCircleArgs: z.ZodObject<{
-    centrePoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
-    axis: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    centrePoint: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
+    axis: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>;
     radius: z.ZodNumber;
 }, z.core.$strip>;
 export type PluginGeomCreateCircleArgs = z.infer<typeof PluginGeomCreateCircleArgs>;
@@ -206,7 +443,7 @@ export type PluginGeomCreateCircleArgs = z.infer<typeof PluginGeomCreateCircleAr
  * | `points` | {@linkcode Vec3Handle}`[]` | Ordered vertex handles of the profile |
  */
 export declare const PluginGeomCreateProfileFromLinePointsArgs: z.ZodObject<{
-    points: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
+    points: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vec3">, string>>>;
 }, z.core.$strip>;
 export type PluginGeomCreateProfileFromLinePointsArgs = z.infer<typeof PluginGeomCreateProfileFromLinePointsArgs>;
 /**
@@ -217,7 +454,7 @@ export type PluginGeomCreateProfileFromLinePointsArgs = z.infer<typeof PluginGeo
  * | `curves` | {@linkcode CurveHandle}`[]` | Ordered curve handles forming a closed loop |
  */
 export declare const PluginGeomCreateProfileFromCurvesArgs: z.ZodObject<{
-    curves: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>>;
+    curves: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"arc">, string>>]>>;
 }, z.core.$strip>;
 export type PluginGeomCreateProfileFromCurvesArgs = z.infer<typeof PluginGeomCreateProfileFromCurvesArgs>;
 /**
@@ -228,7 +465,7 @@ export type PluginGeomCreateProfileFromCurvesArgs = z.infer<typeof PluginGeomCre
  * | `outer` | {@linkcode ProfileHandle} | The outer boundary loop |
  */
 export declare const PluginGeomCreateContourFromProfileArgs: z.ZodObject<{
-    outer: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
+    outer: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
 }, z.core.$strip>;
 export type PluginGeomCreateContourFromProfileArgs = z.infer<typeof PluginGeomCreateContourFromProfileArgs>;
 /**
@@ -240,8 +477,88 @@ export type PluginGeomCreateContourFromProfileArgs = z.infer<typeof PluginGeomCr
  * | `holes` | {@linkcode ProfileHandle}`[]` | Optional inner hole loops |
  */
 export declare const PluginGeomCreateContourFromProfilesArgs: z.ZodObject<{
-    outer: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
-    holes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>>>;
+    outer: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"profile">, string>>>>;
 }, z.core.$strip>;
 export type PluginGeomCreateContourFromProfilesArgs = z.infer<typeof PluginGeomCreateContourFromProfilesArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromFaces}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `faces` | {@linkcode Vec3Components}`[][]` | Face loops — each an ordered array of `{x, y, z}` points (≥3 points per face, ≥4 faces) |
+ */
+export declare const PluginGeomCreateBrepFromFacesArgs: z.ZodObject<{
+    faces: z.ZodArray<z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromFacesArgs = z.infer<typeof PluginGeomCreateBrepFromFacesArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromExtrusion}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | The cross-section to extrude |
+ * | `direction` | {@linkcode Vec3Components} | Extrusion direction (non-zero, finite components) |
+ * | `amount` | `number` | Extrusion distance (finite, non-zero) |
+ */
+export declare const PluginGeomCreateBrepFromExtrusionArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    direction: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromExtrusionArgs = z.infer<typeof PluginGeomCreateBrepFromExtrusionArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromLoft}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `bottomContour` | {@linkcode ContourHandle} | The bottom cross-section |
+ * | `topContour` | {@linkcode ContourHandle} | The top cross-section |
+ */
+export declare const PluginGeomCreateBrepFromLoftArgs: z.ZodObject<{
+    bottomContour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    topContour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromLoftArgs = z.infer<typeof PluginGeomCreateBrepFromLoftArgs>;
+/**
+ * Arguments for {@linkcode PluginGeomCreateApi.brepFromMesh}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `positions` | {@linkcode Vec3Components}`[]` | Vertex positions (≥4) |
+ * | `faces` | `number[][]` | Face loops of indices into `positions` (≥3 indices per face, ≥4 faces) |
+ */
+export declare const PluginGeomCreateBrepFromMeshArgs: z.ZodObject<{
+    positions: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>;
+    faces: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepFromMeshArgs = z.infer<typeof PluginGeomCreateBrepFromMeshArgs>;
+/**
+ * Arguments for the brep boolean constructors —
+ * {@linkcode PluginGeomCreateApi.brepFromUnion},
+ * {@linkcode PluginGeomCreateApi.brepFromSubtraction} (`a` minus `b`), and
+ * {@linkcode PluginGeomCreateApi.brepFromIntersection}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `a` | {@linkcode BrepHandle} | First solid (the subtraction target) |
+ * | `b` | {@linkcode BrepHandle} | Second solid (the subtraction tool) |
+ */
+export declare const PluginGeomCreateBrepBooleanArgs: z.ZodObject<{
+    a: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    b: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+}, z.core.$strip>;
+export type PluginGeomCreateBrepBooleanArgs = z.infer<typeof PluginGeomCreateBrepBooleanArgs>;
 //# sourceMappingURL=index.d.ts.map

package/dist/api/core/geom/create/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/create/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAEhI;;;;;;;;;;GAUG;AACH,8BAAsB,mBAAmB;;IAGvC;;;;;;;;;;;;;;;OAeG;aACa,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,eAAe,CAAC,UAAU,CAAC;IAE/F;;;;;;;;;;;;;;;;;OAiBG;aACa,GAAG,CACjB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,UAAU,EACpB,WAAW,EAAE,UAAU,EACvB,IAAI,EAAE,UAAU,GACf,eAAe,CAAC,SAAS,CAAC;IAE7B;;;;;;;;;;;;;;;;;OAiBG;aACa,MAAM,CACpB,WAAW,EAAE,UAAU,EACvB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,GACb,eAAe,CAAC,YAAY,CAAC;IAEhC;;;;;;;;;;;;;;OAcG;aACa,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,eAAe,CAAC,aAAa,CAAC;IAE3F;;;;;;;;;;;;;OAaG;aACa,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,eAAe,CAAC,aAAa,CAAC;IAExF;;;;;;;;;;;;;;;;;;;;;;OAsBG;aACa,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,UAAU,GAClB,eAAe,CAAC,aAAa,CAAC;IAEjC;;;;;;;;;OASG;aACa,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,CAAC,aAAa,CAAC;IAExF;;;;;;;;;;;;;;;OAeG;aACa,mBAAmB,CACjC,KAAK,EAAE,aAAa,EACpB,KAAK,CAAC,EAAE,aAAa,EAAE,GACtB,eAAe,CAAC,aAAa,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;GAMG;AACH,eAAO,MAAM,yCAAyC;;iBAEpD,CAAA;AAEF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,yCAAyC,CACjD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qCAAqC;;iBAEhD,CAAA;AAEF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,qCAAqC,CAC7C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sCAAsC;;iBAEjD,CAAA;AAEF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,sCAAsC,CAC9C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,uCAAuC;;;iBAGlD,CAAA;AAEF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,uCAAuC,CAC/C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/create/index.ts"],"names":[],"mappings":"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"}

package/dist/api/core/geom/delete/index.d.ts

@@ -18,6 +18,9 @@ export declare abstract class PluginGeomDeleteApi {
      * reclaims its share of the plugin's resource quota. This is a handle-lifecycle
      * operation only and does NOT tear down any engine-side geometry.
      *
+     * @deprecated Use `core.handles.release([profile])` — the universal, batched
+     * release API for every arena handle kind.
+     *
      * @param profile The transient profile handle to release
      * @returns Nothing
      *
@@ -34,6 +37,9 @@ export declare abstract class PluginGeomDeleteApi {
      * reclaims its share of the plugin's resource quota. Handle-lifecycle only; does
      * NOT tear down engine-side geometry, nor the contour's child profile handles.
      *
+     * @deprecated Use `core.handles.release([contour])` — the universal, batched
+     * release API for every arena handle kind.
+     *
      * @param contour The transient contour handle to release
      * @returns Nothing
      *
@@ -55,7 +61,7 @@ export declare abstract class PluginGeomDeleteApi {
  * | `profile` | {@linkcode ProfileHandle} | The transient profile handle to release |
  */
 export declare const PluginGeomDeleteProfileArgs: z.ZodObject<{
-    profile: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"profile">, string>>;
 }, z.core.$strip>;
 export type PluginGeomDeleteProfileArgs = z.infer<typeof PluginGeomDeleteProfileArgs>;
 /**
@@ -66,7 +72,7 @@ export type PluginGeomDeleteProfileArgs = z.infer<typeof PluginGeomDeleteProfile
  * | `contour` | {@linkcode ContourHandle} | The transient contour handle to release |
  */
 export declare const PluginGeomDeleteContourArgs: z.ZodObject<{
-    contour: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"contour">, string>>;
 }, z.core.$strip>;
 export type PluginGeomDeleteContourArgs = z.infer<typeof PluginGeomDeleteContourArgs>;
 //# sourceMappingURL=index.d.ts.map

package/dist/api/core/geom/delete/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/delete/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAElE;;;;;;;;;GASG;AACH,8BAAsB,mBAAmB;;IAGvC;;;;;;;;;;;;;;OAcG;aACa,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC;IAEtE;;;;;;;;;;;;;;;OAeG;aACa,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC;CACvE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAErF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/core/geom/delete/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAElE;;;;;;;;;GASG;AACH,8BAAsB,mBAAmB;;IAGvC;;;;;;;;;;;;;;;;;OAiBG;aACa,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC;IAEtE;;;;;;;;;;;;;;;;;;OAkBG;aACa,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC;CACvE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAErF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

package/dist/api/core/geom/query/arc.d.ts

@@ -119,7 +119,7 @@ export declare abstract class PluginGeomQueryArcApi {
  * | `arc` | {@linkcode ArcHandle} | The arc to query |
  */
 export declare const PluginGeomQueryArcGetRadiusArgs: z.ZodObject<{
-    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+    arc: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryArcGetRadiusArgs = z.infer<typeof PluginGeomQueryArcGetRadiusArgs>;
 /**
@@ -130,7 +130,7 @@ export type PluginGeomQueryArcGetRadiusArgs = z.infer<typeof PluginGeomQueryArcG
  * | `arc` | {@linkcode ArcHandle} | The arc to query |
  */
 export declare const PluginGeomQueryArcGetCentreArgs: z.ZodObject<{
-    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+    arc: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryArcGetCentreArgs = z.infer<typeof PluginGeomQueryArcGetCentreArgs>;
 /**
@@ -141,7 +141,7 @@ export type PluginGeomQueryArcGetCentreArgs = z.infer<typeof PluginGeomQueryArcG
  * | `arc` | {@linkcode ArcHandle} | The arc to query |
  */
 export declare const PluginGeomQueryArcGetAxisArgs: z.ZodObject<{
-    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+    arc: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryArcGetAxisArgs = z.infer<typeof PluginGeomQueryArcGetAxisArgs>;
 /**
@@ -152,7 +152,7 @@ export type PluginGeomQueryArcGetAxisArgs = z.infer<typeof PluginGeomQueryArcGet
  * | `arc` | {@linkcode ArcHandle} | The arc to query |
  */
 export declare const PluginGeomQueryArcGetSweepAngleArgs: z.ZodObject<{
-    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+    arc: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryArcGetSweepAngleArgs = z.infer<typeof PluginGeomQueryArcGetSweepAngleArgs>;
 /**
@@ -163,7 +163,7 @@ export type PluginGeomQueryArcGetSweepAngleArgs = z.infer<typeof PluginGeomQuery
  * | `arc` | {@linkcode ArcHandle} | The arc to query |
  */
 export declare const PluginGeomQueryArcIsValidArgs: z.ZodObject<{
-    arc: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
+    arc: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"arc">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryArcIsValidArgs = z.infer<typeof PluginGeomQueryArcIsValidArgs>;
 //# sourceMappingURL=arc.d.ts.map

package/dist/api/core/geom/query/brep.d.ts

@@ -291,22 +291,22 @@ export declare abstract class PluginGeomQueryBrepApi {
 }
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.listFaces}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepListFacesArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepListFacesArgs = z.infer<typeof PluginGeomQueryBrepListFacesArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.listEdges}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepListEdgesArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepListEdgesArgs = z.infer<typeof PluginGeomQueryBrepListEdgesArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.listVertices}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepListVerticesArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepListVerticesArgs = z.infer<typeof PluginGeomQueryBrepListVerticesArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.listHalfEdges}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepListHalfEdgesArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepListHalfEdgesArgs = z.infer<typeof PluginGeomQueryBrepListHalfEdgesArgs>;
 /**
@@ -319,21 +319,21 @@ export type PluginGeomQueryBrepListHalfEdgesArgs = z.infer<typeof PluginGeomQuer
  * | `vertexIndexB` | `number` | Second vertex index |
  */
 export declare const PluginGeomQueryBrepGetEdgeArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
     vertexIndexA: z.ZodNumber;
     vertexIndexB: z.ZodNumber;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetEdgeArgs = z.infer<typeof PluginGeomQueryBrepGetEdgeArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.hasEdge}. `{ brep, vertexIndexA, vertexIndexB }` */
 export declare const PluginGeomQueryBrepHasEdgeArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
     vertexIndexA: z.ZodNumber;
     vertexIndexB: z.ZodNumber;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepHasEdgeArgs = z.infer<typeof PluginGeomQueryBrepHasEdgeArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.listEdgesBetween}. `{ brep, vertexIndexA, vertexIndexB }` */
 export declare const PluginGeomQueryBrepListEdgesBetweenArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
     vertexIndexA: z.ZodNumber;
     vertexIndexB: z.ZodNumber;
 }, z.core.$strip>;
@@ -347,43 +347,43 @@ export type PluginGeomQueryBrepListEdgesBetweenArgs = z.infer<typeof PluginGeomQ
  * | `vertex` | {@linkcode VertexHandle} | The vertex whose position to read |
  */
 export declare const PluginGeomQueryBrepGetVertexPositionArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
-    vertex: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"vertex">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    vertex: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"vertex">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetVertexPositionArgs = z.infer<typeof PluginGeomQueryBrepGetVertexPositionArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.listVertexPositions}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepListVertexPositionsArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepListVertexPositionsArgs = z.infer<typeof PluginGeomQueryBrepListVertexPositionsArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.getCentroid}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepGetCentroidArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetCentroidArgs = z.infer<typeof PluginGeomQueryBrepGetCentroidArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.getFaceCount}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepGetFaceCountArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetFaceCountArgs = z.infer<typeof PluginGeomQueryBrepGetFaceCountArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.getEdgeCount}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepGetEdgeCountArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetEdgeCountArgs = z.infer<typeof PluginGeomQueryBrepGetEdgeCountArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.getVertexCount}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepGetVertexCountArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetVertexCountArgs = z.infer<typeof PluginGeomQueryBrepGetVertexCountArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.getHalfEdgeCount}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepGetHalfEdgeCountArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetHalfEdgeCountArgs = z.infer<typeof PluginGeomQueryBrepGetHalfEdgeCountArgs>;
 /** Arguments for {@linkcode PluginGeomQueryBrepApi.getBoundingBox}. `{ brep: BrepHandle }` */
 export declare const PluginGeomQueryBrepGetBoundingBoxArgs: z.ZodObject<{
-    brep: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepGetBoundingBoxArgs = z.infer<typeof PluginGeomQueryBrepGetBoundingBoxArgs>;
 /**
@@ -395,8 +395,8 @@ export type PluginGeomQueryBrepGetBoundingBoxArgs = z.infer<typeof PluginGeomQue
  * | `brepB` | {@linkcode BrepHandle} | Second brep |
  */
 export declare const PluginGeomQueryBrepIsEqualArgs: z.ZodObject<{
-    brepA: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
-    brepB: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brepA: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
+    brepB: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../../..").Handle<"brep">, string>>;
 }, z.core.$strip>;
 export type PluginGeomQueryBrepIsEqualArgs = z.infer<typeof PluginGeomQueryBrepIsEqualArgs>;
 //# sourceMappingURL=brep.d.ts.map