brepjs 2.0.0 → 2.0.2

package/dist/brepjs.d.ts

@@ -73,6 +73,12 @@ export declare function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) =>
 
 export declare type AnyShape = Vertex | Edge | Wire | Face | Shell | Solid | CompSolid | Compound;
 
+/**
+ * Applies glue optimization to a boolean operation.
+ *
+ * @param op - Boolean operation builder with SetGlue method
+ * @param optimisation - Optimization level: 'none', 'commonFace', or 'sameFace'
+ */
 export declare function applyGlue(op: {
     SetGlue(glue: OcType): void;
 }, optimisation: 'none' | 'commonFace' | 'sameFace'): void;
@@ -83,8 +89,16 @@ declare interface ApproximationOptions {
     maxSegments?: number;
 }
 
+/**
+ * @deprecated Use toOcDir from occtBoundary.ts with Vec3 tuples instead.
+ * @see toOcDir
+ */
 export declare function asDir(coords: Point): OcType;
 
+/**
+ * @deprecated Use toOcPnt from occtBoundary.ts with Vec3 tuples instead.
+ * @see toOcPnt
+ */
 export declare function asPnt(coords: Point): OcType;
 
 export declare const assembleWire: (listOfEdges: (Edge | Wire)[]) => Result<Wire>;
@@ -277,6 +291,24 @@ export declare interface BooleanOptions {
     strategy?: 'native' | 'pairwise';
 }
 
+/**
+ * @deprecated Use getBounds() from shapeFns.ts which returns a Bounds3D plain object.
+ * @example
+ * // Before (legacy):
+ * const bbox = shape.boundingBox;
+ * const center = bbox.center;
+ *
+ * // After (functional):
+ * import { getBounds, type Bounds3D } from 'brepjs';
+ * const bounds: Bounds3D = getBounds(shape);
+ * const center = [
+ *   (bounds.xMin + bounds.xMax) / 2,
+ *   (bounds.yMin + bounds.yMax) / 2,
+ *   (bounds.zMin + bounds.zMax) / 2
+ * ];
+ *
+ * @see getBounds, Bounds3D
+ */
 export declare class BoundingBox extends WrappingObj<OcType> {
     constructor(wrapped?: OcType);
     get repr(): string;
@@ -343,6 +375,9 @@ export declare interface BSplineApproximationConfig {
  */
 export declare function bug(location: string, message: string): never;
 
+/**
+ * Builds a TopoDS_Compound from Shape3D instances.
+ */
 export declare function buildCompound(shapes: Shape3D[]): OcShape;
 
 /**
@@ -391,7 +426,7 @@ export declare type ChamferRadius = number | {
 };
 
 /**
- * Clear the mesh cache. Call this after modifying shapes to avoid stale results.
+ * Clear all mesh caches. Call this after modifying shapes to avoid stale results.
  */
 export declare function clearMeshCache(): void;
 
@@ -574,6 +609,10 @@ export declare function createDistanceQuery(referenceShape: FnAnyShape): {
 /** Create a disposable shape handle. */
 export declare function createHandle(ocShape: OcShape): ShapeHandle;
 
+/**
+ * @deprecated Use createNamedPlane from planeOps.ts which returns a functional Plane.
+ * @see createNamedPlane from planeOps.ts (exported as fnCreateNamedPlane from brepjs)
+ */
 export declare const createNamedPlane: (plane: PlaneName, sourceOrigin?: Point | number) => Result<Plane>;
 
 /** Create a disposable handle for any OCCT object. */
@@ -1101,8 +1140,8 @@ export declare function err<E>(error: E): Err<E>;
 
 /** Create an XCAF document from shape configs and export as STEP blob. */
 export declare function exportAssemblySTEP(shapes?: FnShapeConfig[], { unit, modelUnit }?: {
-    unit?: FnSupportedUnit;
-    modelUnit?: FnSupportedUnit;
+    unit?: SupportedUnit;
+    modelUnit?: SupportedUnit;
 }): Result<Blob>;
 
 export declare function exportSTEP(shapes?: ShapeConfig[], { unit, modelUnit }?: {
@@ -1113,10 +1152,15 @@ export declare function exportSTEP(shapes?: ShapeConfig[], { unit, modelUnit }?:
 /** Extrude a face along a vector to produce a solid. */
 export declare function extrudeFace(face: FnFace, extrusionVec: Vec3): FnSolid;
 
-export declare interface ExtrusionProfile {
+/** Configuration for extrusion profile scaling along the path. */
+declare interface ExtrusionProfile {
+    /** Profile curve type: 's-curve' for smooth easing, 'linear' for constant scaling */
     profile?: 's-curve' | 'linear';
+    /** End scale factor (1 = same size, 0.5 = half size at end) */
     endFactor?: number;
 }
+export { ExtrusionProfile }
+export { ExtrusionProfile as FnExtrusionProfile }
 
 export declare class Face extends Shape {
     protected _geomAdaptor(): OcType;
@@ -1181,12 +1225,12 @@ export declare function faceFinder(): FaceFinderFn;
 export declare interface FaceFinderFn extends ShapeFinder<FnFace> {
     readonly inDirection: (dir?: 'X' | 'Y' | 'Z' | Vec3, angle?: number) => FaceFinderFn;
     readonly parallelTo: (dir?: 'X' | 'Y' | 'Z' | Vec3) => FaceFinderFn;
-    readonly ofSurfaceType: (surfaceType: SurfaceType_2) => FaceFinderFn;
+    readonly ofSurfaceType: (surfaceType: SurfaceType) => FaceFinderFn;
     readonly atDistance: (distance: number, point?: Vec3) => FaceFinderFn;
 }
 
 /** Get the surface type of a face (unwrapped convenience). */
-export declare function faceGeomType(face: FnFace): SurfaceType_2;
+export declare function faceGeomType(face: FnFace): SurfaceType;
 
 declare type FaceOrEdge = Face | Edge;
 
@@ -1234,12 +1278,6 @@ export declare interface FaceTriangulation {
     verticesNormals: number[];
 }
 
-declare interface FaceTriangulation_2 {
-    vertices: number[];
-    trianglesIndexes: number[];
-    verticesNormals: number[];
-}
-
 export declare type FilletRadius = number | [number, number];
 
 export declare type FilterFcn<Type> = {
@@ -1384,7 +1422,7 @@ export declare type FnAnyShape = FnVertex | FnEdge | FnWire | FnFace | FnShell |
 export declare function fnBuildCompound(shapes: FnAnyShape[]): FnCompound;
 
 /** Extrude a wire along a normal with optional profile shaping. */
-export declare function fnComplexExtrude(wire: FnWire, center: Vec3, normal: Vec3, profileShape?: FnExtrusionProfile, shellMode?: boolean): Result<FnShape3D | [FnShape3D, FnWire, FnWire]>;
+export declare function fnComplexExtrude(wire: FnWire, center: Vec3, normal: Vec3, profileShape?: ExtrusionProfile, shellMode?: boolean): Result<FnShape3D | [FnShape3D, FnWire, FnWire]>;
 
 export declare type FnCompound = ShapeHandle & {
     readonly [__brand]: 'compound';
@@ -1426,11 +1464,6 @@ export declare function fnExportSTL(shape: FnAnyShape, { tolerance, angularToler
     binary?: boolean;
 }): Result<Blob>;
 
-export declare interface FnExtrusionProfile {
-    profile?: 's-curve' | 'linear';
-    endFactor?: number;
-}
-
 export declare type FnFace = ShapeHandle & {
     readonly [__brand]: 'face';
 };
@@ -1515,17 +1548,6 @@ export declare interface FnShapeConfig {
     name?: string;
 }
 
-export declare interface FnShapeMesh {
-    triangles: Uint32Array;
-    vertices: Float32Array;
-    normals: Float32Array;
-    faceGroups: {
-        start: number;
-        count: number;
-        faceId: number;
-    }[];
-}
-
 export declare type FnShell = ShapeHandle & {
     readonly [__brand]: 'shell';
 };
@@ -1540,13 +1562,11 @@ export declare type FnSolid = ShapeHandle & {
     readonly [__brand]: 'solid';
 };
 
-export declare type FnSupportedUnit = 'M' | 'CM' | 'MM' | 'INCH' | 'FT' | 'm' | 'mm' | 'cm' | 'inch' | 'ft';
-
 /** Extrude a wire with support surface. */
-export declare function fnSupportExtrude(wire: FnWire, center: Vec3, normal: Vec3, support: OcType_3): Result<FnShape3D>;
+export declare function fnSupportExtrude(wire: FnWire, center: Vec3, normal: Vec3, support: OcType_4): Result<FnShape3D>;
 
 /** Extrude a wire with twist along a normal. Angle is in degrees. */
-export declare function fnTwistExtrude(wire: FnWire, angleDegrees: number, center: Vec3, normal: Vec3, profileShape?: FnExtrusionProfile, shellMode?: boolean): Result<FnShape3D | [FnShape3D, FnWire, FnWire]>;
+export declare function fnTwistExtrude(wire: FnWire, angleDegrees: number, center: Vec3, normal: Vec3, profileShape?: ExtrusionProfile, shellMode?: boolean): Result<FnShape3D | [FnShape3D, FnWire, FnWire]>;
 
 /** Get the UV coordinates on a face for a given 3D point. */
 export declare function fnUvCoordinates(face: FnFace, point: PointInput): [number, number];
@@ -1560,13 +1580,13 @@ export declare type FnWire = ShapeHandle & {
 };
 
 /** Extract Vec3 from OCCT gp_Dir */
-export declare function fromOcDir(ocDir: OcType_2): Vec3;
+export declare function fromOcDir(ocDir: OcType_3): Vec3;
 
 /** Extract Vec3 from OCCT gp_Pnt */
-export declare function fromOcPnt(ocPnt: OcType_2): Vec3;
+export declare function fromOcPnt(ocPnt: OcType_3): Vec3;
 
 /** Extract Vec3 from OCCT gp_Vec */
-export declare function fromOcVec(ocVec: OcType_2): Vec3;
+export declare function fromOcVec(ocVec: OcType_3): Vec3;
 
 export declare const fuse2D: (first: Shape2D, second: Shape2D) => Blueprint | Blueprints | CompoundBlueprint | null;
 
@@ -1588,10 +1608,14 @@ export declare const fuseBlueprints: (first: Blueprint, second: Blueprint) => nu
 export declare function fuseShapes(a: FnShape3D, b: FnShape3D, { optimisation, simplify }?: BooleanOptions): Result<FnShape3D>;
 
 /** Register a deletable value for GC when the given object is collected. */
-export declare function GCWithObject(obj: any): <T extends Deletable>(value: T) => T;
+declare function gcWithObject(obj: any): <T extends Deletable>(value: T) => T;
+export { gcWithObject as GCWithObject }
+export { gcWithObject }
 
 /** Register a deletable value for GC when the scope function is collected. */
-export declare function GCWithScope(): <T extends Deletable>(value: T) => T;
+declare function gcWithScope(): <T extends Deletable>(value: T) => T;
+export { gcWithScope as GCWithScope }
+export { gcWithScope }
 
 /**
  * Sketchers allow the user to draw a two dimensional shape using segments of
@@ -1884,14 +1908,10 @@ export declare function genericSweep(wire: Wire, spine: Wire, sweepConfig: Gener
 
 export declare function genericSweep(wire: Wire, spine: Wire, sweepConfig: GenericSweepConfig, shellMode?: false): Result<Shape3D>;
 
-export declare interface GenericSweepConfig {
-    frenet?: boolean;
+/** Configuration for sweep operations in the OO API. */
+export declare interface GenericSweepConfig extends Omit<SweepConfig, 'auxiliarySpine'> {
+    /** Auxiliary spine for twist control (Wire or Edge in OO API) */
     auxiliarySpine?: Wire | Edge;
-    law?: OcType;
-    transitionMode?: 'right' | 'transformed' | 'round';
-    withContact?: boolean;
-    support?: OcType;
-    forceProfileSpineOthogonality?: boolean;
 }
 
 export declare type GenericTopo = OcShape;
@@ -1920,7 +1940,7 @@ export declare function getShapeKind(shape: FnAnyShape): ShapeKind;
 export declare function getSingleFace(f: SingleFace, shape: AnyShape): Result<Face>;
 
 /** Get the geometric surface type of a face. */
-export declare function getSurfaceType(face: FnFace): Result<SurfaceType_2>;
+export declare function getSurfaceType(face: FnFace): Result<SurfaceType>;
 
 /** Get all wires of a shape as branded Wire handles. */
 export declare function getWires(shape: FnAnyShape): FnWire[];
@@ -2006,10 +2026,22 @@ export declare function loftWires(wires: FnWire[], { ruled, startPoint, endPoint
 
 export declare function lookFromPlane(projectionPlane: ProjectionPlane): ProjectionCamera;
 
+/**
+ * @deprecated Use makeOcAx1 from occtBoundary.ts with Vec3 tuples instead.
+ * @see makeOcAx1
+ */
 export declare const makeAx1: (center: Point, dir: Point) => OcType;
 
+/**
+ * @deprecated Use makeOcAx2 from occtBoundary.ts with Vec3 tuples instead.
+ * @see makeOcAx2
+ */
 export declare const makeAx2: (center: Point, dir: Point, xDir?: Point) => OcType;
 
+/**
+ * @deprecated Use makeOcAx3 from occtBoundary.ts with Vec3 tuples instead.
+ * @see makeOcAx3
+ */
 export declare const makeAx3: (center: Point, dir: Point, xDir?: Point) => OcType;
 
 export declare const makeBaseBox: (xLength: number, yLength: number, zLength: number) => Shape3D;
@@ -2144,10 +2176,12 @@ export declare interface MeshOptions {
 export declare function meshShape(shape: FnAnyShape, { tolerance, angularTolerance, skipNormals, cache, }?: MeshOptions & {
     skipNormals?: boolean;
     cache?: boolean;
-}): FnShapeMesh;
+}): ShapeMesh;
 
 /** Mesh the edges of a shape as line segments for edge rendering. */
-export declare function meshShapeEdges(shape: FnAnyShape, { tolerance, angularTolerance }?: MeshOptions): EdgeMesh;
+export declare function meshShapeEdges(shape: FnAnyShape, { tolerance, angularTolerance, cache }?: MeshOptions & {
+    cache?: boolean;
+}): EdgeMesh;
 
 export declare function mirror(shape: OcType, inputPlane?: Plane | PlaneName | Point, origin?: Point): OcType;
 
@@ -2175,13 +2209,19 @@ declare type OcShape = any;
 
 declare type OcType = any;
 
+/**
+ * Shared utilities for extrusion operations.
+ * Used by both class-based (extrude.ts) and functional (extrudeFns.ts) APIs.
+ */
 declare type OcType_2 = any;
 
+declare type OcType_3 = any;
+
 /**
  * Functional extrusion operations using Vec3 tuples and branded shape types.
  * Immutable: all functions return new shapes without disposing inputs.
  */
-declare type OcType_3 = any;
+declare type OcType_4 = any;
 
 declare interface Offset2DConfig {
     lineJoinType?: 'miter' | 'bevel' | 'round';
@@ -2228,6 +2268,20 @@ export declare interface PhysicalProps {
 /** Pivot plane by rotating around an axis. */
 export declare function pivotPlane(plane: FnPlane, angleDeg: number, axis?: Vec3): FnPlane;
 
+/**
+ * @deprecated Use the Plane interface from planeTypes.ts with planeOps functions instead.
+ * @example
+ * // Before (legacy):
+ * const plane = new Plane([0, 0, 0], [1, 0, 0], [0, 0, 1]);
+ * const moved = plane.translate([1, 0, 0]);
+ *
+ * // After (functional):
+ * import { createPlane, translatePlane, type Plane as FnPlane } from 'brepjs';
+ * const plane: FnPlane = createPlane([0, 0, 0], [1, 0, 0], [0, 0, 1]);
+ * const moved = translatePlane(plane, [1, 0, 0]);
+ *
+ * @see createPlane, translatePlane, pivotPlane, rotatePlane2DAxes
+ */
 export declare class Plane {
     oc: OpenCascadeInstance;
     xDir: Vector;
@@ -2381,9 +2435,11 @@ export declare function scaleShape<T extends FnAnyShape>(shape: T, factor: numbe
 export declare function serializeShape(shape: FnAnyShape): string;
 
 /**
- * Set the maximum cache size. Existing entries beyond the new limit are evicted.
+ * Set the maximum cache size for the legacy cache.
+ * Note: WeakMap caches are automatically managed by GC and don't have a size limit.
+ * @deprecated The WeakMap-based cache doesn't use size limits
  */
-export declare function setMeshCacheSize(size: number): void;
+export declare function setMeshCacheSize(_size: number): void;
 
 export declare const setOC: (oc: OpenCascadeInstance) => void;
 
@@ -2466,9 +2522,10 @@ export declare class Shape<Type extends Deletable = OcShape> extends WrappingObj
      *
      * @category Shape Export
      */
-    meshEdges({ tolerance, angularTolerance }?: {
-        tolerance?: number | undefined;
-        angularTolerance?: number | undefined;
+    meshEdges({ tolerance, angularTolerance, cache, }?: {
+        tolerance?: number;
+        angularTolerance?: number;
+        cache?: boolean;
     }): {
         lines: number[];
         edgeGroups: {
@@ -2537,7 +2594,7 @@ export declare interface ShapeHandle {
 
 export declare type ShapeKind = 'vertex' | 'edge' | 'wire' | 'face' | 'shell' | 'solid' | 'compsolid' | 'compound';
 
-export declare interface ShapeMesh {
+declare interface ShapeMesh {
     triangles: Uint32Array;
     vertices: Float32Array;
     normals: Float32Array;
@@ -2547,29 +2604,25 @@ export declare interface ShapeMesh {
         faceId: number;
     }[];
 }
+export { ShapeMesh as FnShapeMesh }
+export { ShapeMesh }
 
 declare namespace ShapesModule {
     export {
-        registerQueryModule,
-        isNumber,
-        isChamferRadius,
-        isFilletRadius,
         isShape3D_2 as isShape3D,
-        buildCompoundOc,
-        buildCompound,
-        applyGlue,
-        fuseAll,
-        cutAll,
         CurveType,
         AnyShape,
         Shape3D,
         CurveLike,
-        ChamferRadius,
-        FilletRadius,
-        RadiusConfig,
         FaceTriangulation,
         ShapeMesh,
         SurfaceType,
+        ChamferRadius,
+        FilletRadius,
+        RadiusConfig,
+        isNumber,
+        isChamferRadius,
+        isFilletRadius,
         BooleanOperationOptions,
         Shape,
         Vertex,
@@ -2583,7 +2636,13 @@ declare namespace ShapesModule {
         Shell,
         Solid,
         CompSolid,
-        Compound
+        Compound,
+        fuseAll,
+        cutAll,
+        buildCompound,
+        buildCompoundOc,
+        applyGlue,
+        registerQueryModule
     }
 }
 
@@ -2941,7 +3000,10 @@ declare type StartSplineTangent = number | Point2D;
 /** Stretch a blueprint. Returns a new Blueprint. */
 export declare function stretchBlueprint(bp: Blueprint, ratio: number, direction: Point2D, origin?: Point2D): Blueprint;
 
-export declare type SupportedUnit = 'M' | 'CM' | 'MM' | 'INCH' | 'FT' | 'm' | 'mm' | 'cm' | 'inch' | 'ft';
+/** Supported length units for STEP export. */
+declare type SupportedUnit = 'M' | 'CM' | 'MM' | 'INCH' | 'FT' | 'm' | 'mm' | 'cm' | 'inch' | 'ft';
+export { SupportedUnit as FnSupportedUnit }
+export { SupportedUnit }
 
 export declare const supportExtrude: (wire: Wire, center: Point, normal: Point, support: OcType) => Result<Shape3D>;
 
@@ -2955,18 +3017,26 @@ export declare class SurfacePhysicalProperties extends PhysicalProperties {
 
 export declare type SurfaceType = 'PLANE' | 'CYLINDRE' | 'CONE' | 'SPHERE' | 'TORUS' | 'BEZIER_SURFACE' | 'BSPLINE_SURFACE' | 'REVOLUTION_SURFACE' | 'EXTRUSION_SURFACE' | 'OFFSET_SURFACE' | 'OTHER_SURFACE';
 
-declare type SurfaceType_2 = 'PLANE' | 'CYLINDRE' | 'CONE' | 'SPHERE' | 'TORUS' | 'BEZIER_SURFACE' | 'BSPLINE_SURFACE' | 'REVOLUTION_SURFACE' | 'EXTRUSION_SURFACE' | 'OFFSET_SURFACE' | 'OTHER_SURFACE';
-
 /** Sweep a wire profile along a spine. Returns a solid or shell+wires. */
 export declare function sweep(wire: FnWire, spine: FnWire, config?: SweepConfig, shellMode?: boolean): Result<FnShape3D | [FnShape3D, FnWire, FnWire]>;
 
+/** Configuration for sweep/pipe operations along a spine. */
 export declare interface SweepConfig {
+    /** Use Frenet trihedron for profile orientation */
     frenet?: boolean;
-    auxiliarySpine?: FnWire | FnEdge;
-    law?: OcType_3;
+    /** Auxiliary spine for twist control */
+    auxiliarySpine?: {
+        wrapped: OcType_2;
+    };
+    /** Scaling law along the path */
+    law?: OcType_2;
+    /** Transition mode at corners: 'right' (sharp), 'transformed', or 'round' */
     transitionMode?: 'right' | 'transformed' | 'round';
+    /** Enable contact detection */
     withContact?: boolean;
-    support?: OcType_3;
+    /** Support surface for constrained sweeps */
+    support?: OcType_2;
+    /** Force profile to be orthogonal to spine */
     forceProfileSpineOthogonality?: boolean;
 }
 
@@ -2978,7 +3048,7 @@ export declare function textBlueprints(text: string, { startX, startY, fontSize,
 }): Blueprints;
 
 /** Convert Vec3 to OCCT gp_Vec. Caller must call .delete() when done. */
-export declare function toOcVec(v: Vec3): OcType_2;
+export declare function toOcVec(v: Vec3): OcType_3;
 
 export declare type TopoEntity = 'vertex' | 'edge' | 'wire' | 'face' | 'shell' | 'solid' | 'solidCompound' | 'compound' | 'shape';
 
@@ -2988,6 +3058,20 @@ export declare function toVec2(p: PointInput): Vec2;
 /** Normalize any point input to Vec3 */
 export declare function toVec3(p: PointInput): Vec3;
 
+/**
+ * @deprecated Use standalone transform functions instead.
+ * @example
+ * // Before (legacy):
+ * const trsf = new Transformation();
+ * trsf.translate([1, 0, 0]);
+ * const newShape = trsf.transform(shape.wrapped);
+ *
+ * // After (functional):
+ * import { translateShape } from 'brepjs';
+ * const newShape = translateShape(shape, [1, 0, 0]);
+ *
+ * @see translateShape, rotateShape, mirrorShape, scaleShape
+ */
 export declare class Transformation extends WrappingObj<OcType> {
     constructor(transform?: OcType);
     translate(xDist: number, yDist: number, zDist: number): Transformation;
@@ -3020,7 +3104,7 @@ export declare function translateShape<T extends FnAnyShape>(shape: T, v: Vec3):
  * Triangulate a face. Returns triangulation data or null if unavailable.
  * @deprecated Use meshShape() instead for better performance via bulk C++ extraction.
  */
-export declare function triangulateFace(face: FnFace, index0?: number, skipNormals?: boolean): FaceTriangulation_2 | null;
+export declare function triangulateFace(face: FnFace, index0?: number, skipNormals?: boolean): FaceTriangulation | null;
 
 /**
  * Wraps a throwing function into a Result.
@@ -3115,6 +3199,18 @@ export declare function vecScale(v: Vec3, s: number): Vec3;
 
 export declare function vecSub(a: Vec3, b: Vec3): Vec3;
 
+/**
+ * @deprecated Use Vec3 tuples with vecOps functions instead.
+ * @example
+ * // Before (legacy):
+ * const v = new Vector([1, 2, 3]);
+ * const result = v.add(new Vector([4, 5, 6]));
+ *
+ * // After (functional):
+ * import { vecAdd, type Vec3 } from 'brepjs';
+ * const v: Vec3 = [1, 2, 3];
+ * const result = vecAdd(v, [4, 5, 6]);
+ */
 export declare class Vector extends WrappingObj<OcType> {
     constructor(vector?: Point);
     get repr(): string;
@@ -3167,13 +3263,13 @@ export declare class Wire extends _1DShape {
 }
 
 /** Execute fn with a temporary OCCT gp_Dir, auto-deleted after. */
-export declare function withOcDir<T>(v: Vec3, fn: (ocDir: OcType_2) => T): T;
+export declare function withOcDir<T>(v: Vec3, fn: (ocDir: OcType_3) => T): T;
 
 /** Execute fn with a temporary OCCT gp_Pnt, auto-deleted after. */
-export declare function withOcPnt<T>(v: Vec3, fn: (ocPnt: OcType_2) => T): T;
+export declare function withOcPnt<T>(v: Vec3, fn: (ocPnt: OcType_3) => T): T;
 
 /** Execute fn with a temporary OCCT gp_Vec, auto-deleted after. */
-export declare function withOcVec<T>(v: Vec3, fn: (ocVec: OcType_2) => T): T;
+export declare function withOcVec<T>(v: Vec3, fn: (ocVec: OcType_3) => T): T;
 
 /** Execute a function with a disposal scope. Resources registered with the scope
  *  are automatically cleaned up when the function returns. */