ocjs-fluidcad 1.4.0 → 1.6.0

package/dist/opencascade.fluidcad.multi-threaded.d.ts

@@ -16010,6 +16010,406 @@ export declare class Law_Function extends Standard_Transient {
   [Symbol.dispose](): void;
 }
 
+/**
+ * Implements a projector object. To transform and project Points and Planes. This object is designed to be used in the removal of hidden lines and is returned by the Prs3d_Projector::Projector function. You define the projection of the selected shape by calling one of the following functions:
+ *
+ * - `HLRBRep_Algo::Projector`, or
+ * - `HLRBRep_PolyAlgo::Projector` The choice depends on the algorithm, which you are using. The parameters of the view are defined at the time of construction of a Prs3d_Projector object.
+ */
+export declare class HLRAlgo_Projector {
+  constructor();
+  /**
+   * Creates an axonometric projector. <CS> is the viewing coordinate system.
+   */
+  constructor(CS: gp_Ax2);
+  /**
+   * Creates a perspective projector. <CS> is the viewing coordinate system.
+   */
+  constructor(CS: gp_Ax2, Focus: number);
+  /**
+   * build a Projector with automatic minmax directions.
+   */
+  constructor(T: gp_Trsf, Persp: boolean, Focus: number);
+  /**
+   * build a Projector with given minmax directions.
+   */
+  constructor(T: gp_Trsf, Persp: boolean, Focus: number, v1: gp_Vec2d, v2: gp_Vec2d, v3: gp_Vec2d);
+  Set(T: gp_Trsf, Persp: boolean, Focus: number): void;
+  Directions(D1: gp_Vec2d, D2: gp_Vec2d, D3: gp_Vec2d): void;
+  /**
+   * to compute with the given scale and translation.
+   */
+  Scaled(On?: boolean): void;
+  /**
+   * Returns True if there is a perspective transformation.
+   */
+  Perspective(): boolean;
+  /**
+   * Returns the active transformation.
+   */
+  Transformation(): gp_Trsf;
+  /**
+   * Returns the active inverted transformation.
+   */
+  InvertedTransformation(): gp_Trsf;
+  /**
+   * Returns the original transformation.
+   */
+  FullTransformation(): gp_Trsf;
+  /**
+   * Returns the focal length.
+   */
+  Focus(): number;
+  Transform(D: gp_Vec): void;
+  Transform(Pnt: gp_Pnt): void;
+  /**
+   * Transform and apply perspective if needed.
+   * @param Pout Mutated in place; read the updated value from this argument after the call.
+   */
+  Project(P: gp_Pnt, Pout: gp_Pnt2d): void;
+  /**
+   * Transform and apply perspective if needed.
+   * @returns A result object with fields:
+   * - `X`: updated value from the call.
+   * - `Y`: updated value from the call.
+   * - `Z`: updated value from the call.
+   */
+  Project(P: gp_Pnt, X: number, Y: number, Z: number): { X: number; Y: number; Z: number };
+  /**
+   * Transform and apply perspective if needed.
+   * @param Pout Mutated in place; read the updated value from this argument after the call.
+   * @param D1out Mutated in place; read the updated value from this argument after the call.
+   */
+  Project(P: gp_Pnt, D1: gp_Vec, Pout: gp_Pnt2d, D1out: gp_Vec2d): void;
+  /**
+   * return a line going through the eye towards the 2d point <X,Y>.
+   */
+  Shoot(X: number, Y: number): gp_Lin;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
+/**
+ * Inherited from InternalAlgo to provide methods with Shape from `TopoDS`. A framework to compute a shape as seen in a projection plane. This is done by calculating the visible and the hidden parts of the shape. {@link HLRBRep_Algo | `HLRBRep_Algo`} works with three types of entity:
+ *
+ * - shapes to be visualized
+ * - edges in these shapes (these edges are the basic entities which will be visualized or hidden), and
+ * - faces in these shapes which hide the edges. {@link HLRBRep_Algo | `HLRBRep_Algo`} is based on the principle of comparing each edge of the shape to be visualized with each of its faces, and calculating the visible and the hidden parts of each edge. For a given projection, {@link HLRBRep_Algo | `HLRBRep_Algo`} calculates a set of lines characteristic of the object being represented. It is also used in conjunction with the {@link HLRBRep_HLRToShape | `HLRBRep_HLRToShape`} extraction utilities, which reconstruct a new, simplified shape from a selection of calculation results.
+ * This new shape is made up of edges, which represent the shape visualized in the projection. {@link HLRBRep_Algo | `HLRBRep_Algo`} takes the shape itself into account whereas {@link HLRBRep_PolyAlgo | `HLRBRep_PolyAlgo`} works with a polyhedral simplification of the shape.
+ * When you use {@link HLRBRep_Algo | `HLRBRep_Algo`}, you obtain an exact result, whereas, when you use {@link HLRBRep_PolyAlgo | `HLRBRep_PolyAlgo`}, you reduce computation time but obtain polygonal segments. In the case of complicated shapes, {@link HLRBRep_Algo | `HLRBRep_Algo`} may be time-consuming. An {@link HLRBRep_Algo | `HLRBRep_Algo`} object provides a framework for:
+ * - defining the point of view
+ * - identifying the shape or shapes to be visualized
+ * - calculating the outlines
+ * - calculating the visible and hidden lines of the shape. Warning
+ * - Superimposed lines are not eliminated by this algorithm.
+ * - There must be no unfinished objects inside the shape you wish to visualize.
+ * - Points are not treated.
+ * - Note that this is not the sort of algorithm used in generating shading, which calculates the visible and hidden parts of each face in a shape to be visualized by comparing each face in the shape with every other face in the same shape.
+ */
+export declare class HLRBRep_Algo extends HLRBRep_InternalAlgo {
+  /**
+   * Constructs an empty framework for the calculation of visible and hidden lines of a shape in a projection. Use the function:
+   *
+   * - Projector to define the point of view
+   * - Add to select the shape or shapes to be visualized
+   * - Update to compute the outlines of the shape, and
+   * - Hide to compute the visible and hidden lines of the shape.
+   */
+  constructor();
+  constructor(A: HLRBRep_Algo);
+  /**
+   * add the Shape .
+   */
+  Add(S: TopoDS_Shape, SData: Standard_Transient, nbIso: number): void;
+  /**
+   * Adds the shape S to this framework, and specifies the number of isoparameters nbiso desired in visualizing S. You may add as many shapes as you wish. Use the function Add once for each shape.
+   */
+  Add(S: TopoDS_Shape, nbIso: number): void;
+  /**
+   * return the index of the Shape and return 0 if the Shape is not found.
+   */
+  Index(S: TopoDS_Shape): number;
+  /**
+   * return the index of the Shape and return 0 if the Shape is not found.
+   */
+  Index(S: HLRTopoBRep_OutLiner): number;
+  /**
+   * nullify all the results of OutLiner from HLRTopoBRep.
+   */
+  OutLinedShapeNullify(): void;
+  static get_type_name(): string;
+  static get_type_descriptor(): unknown;
+  DynamicType(): unknown;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
+/**
+ * A framework for filtering the computation results of an {@link HLRBRep_Algo | `HLRBRep_Algo`} algorithm by extraction. From the results calculated by the algorithm on a shape, a filter returns the type of edge you want to identify. You can choose any of the following types of output:
+ *
+ * - visible sharp edges
+ * - hidden sharp edges
+ * - visible smooth edges
+ * - hidden smooth edges
+ * - visible sewn edges
+ * - hidden sewn edges
+ * - visible outline edges
+ * - hidden outline edges.
+ * - visible isoparameters and
+ * - hidden isoparameters. Sharp edges present a C0 continuity (non G1). Smooth edges present a G1 continuity (non G2). Sewn edges present a C2 continuity. The result is composed of 2D edges in the projection plane of the view which the algorithm has worked with. These 2D edges are not included in the data structure of the visualized shape. In order to obtain a complete image, you must combine the shapes given by each of the chosen filters. The construction of the shape does not call a new computation of the algorithm, but only reads its internal results. The methods of this shape are almost identic to those of the HLRBrep_PolyHLRToShape class.
+ */
+export declare class HLRBRep_HLRToShape {
+  /**
+   * Constructs a framework for filtering the results of the {@link HLRBRep_Algo | `HLRBRep_Algo`} algorithm, A. Use the extraction filters to obtain the results you want for A.
+   */
+  constructor(A: HLRBRep_Algo);
+  // dropped: DrawFace param 3 resolves to excluded type HLRBRep_Data
+  /**
+   * Return visible sharp edges (of C0-continuity).
+   */
+  VCompound(): TopoDS_Shape;
+  /**
+   * Return visible sharp edges (of C0-continuity) of specified shape.
+   */
+  VCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return visible smooth edges (G1-continuity between two surfaces).
+   */
+  Rg1LineVCompound(): TopoDS_Shape;
+  /**
+   * Return visible smooth edges (G1-continuity between two surfaces) of specified shape.
+   */
+  Rg1LineVCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return visible sewn edges (of CN-continuity on one surface).
+   */
+  RgNLineVCompound(): TopoDS_Shape;
+  /**
+   * Return visible sewn edges (of CN-continuity on one surface) of specified shape.
+   */
+  RgNLineVCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return visible outline edges ("silhouette").
+   */
+  OutLineVCompound(): TopoDS_Shape;
+  /**
+   * Return visible outline edges ("silhouette") of specified shape.
+   */
+  OutLineVCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return visible outline edges ("silhouette").
+   */
+  OutLineVCompound3d(): TopoDS_Shape;
+  /**
+   * Return visible isoparameters.
+   */
+  IsoLineVCompound(): TopoDS_Shape;
+  /**
+   * Return visible isoparameters of specified shape.
+   */
+  IsoLineVCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return hidden sharp edges (of C0-continuity).
+   */
+  HCompound(): TopoDS_Shape;
+  /**
+   * Return hidden sharp edges (of C0-continuity) of specified shape.
+   */
+  HCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return hidden smooth edges (G1-continuity between two surfaces).
+   */
+  Rg1LineHCompound(): TopoDS_Shape;
+  /**
+   * Return hidden smooth edges (G1-continuity between two surfaces) of specified shape.
+   */
+  Rg1LineHCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return hidden sewn edges (of CN-continuity on one surface).
+   */
+  RgNLineHCompound(): TopoDS_Shape;
+  /**
+   * Return hidden sewn edges (of CN-continuity on one surface) of specified shape.
+   */
+  RgNLineHCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return hidden outline edges ("silhouette").
+   */
+  OutLineHCompound(): TopoDS_Shape;
+  /**
+   * Return hidden outline edges ("silhouette") of specified shape.
+   */
+  OutLineHCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Return hidden isoparameters.
+   */
+  IsoLineHCompound(): TopoDS_Shape;
+  /**
+   * Return hidden isoparameters of specified shape.
+   */
+  IsoLineHCompound(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Returns compound of resulting edges of required type and visibility, taking into account the kind of space (2d or 3d)
+   */
+  CompoundOfEdges(type_: HLRBRep_TypeOfResultingEdge, visible: boolean, In3d: boolean): TopoDS_Shape;
+  /**
+   * For specified shape returns compound of resulting edges of required type and visibility, taking into account the kind of space (2d or 3d)
+   */
+  CompoundOfEdges(S: TopoDS_Shape, type_: HLRBRep_TypeOfResultingEdge, visible: boolean, In3d: boolean): TopoDS_Shape;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
+export declare class HLRBRep_InternalAlgo extends Standard_Transient {
+  constructor();
+  constructor(A: HLRBRep_InternalAlgo);
+  // dropped: DataStructure return resolves to excluded type HLRBRep_Data
+  /**
+   * set the projector.
+   */
+  Projector(P: HLRAlgo_Projector): void;
+  /**
+   * set the projector.
+   */
+  Projector(): HLRAlgo_Projector;
+  /**
+   * update the DataStructure.
+   */
+  Update(): void;
+  /**
+   * add the shape .
+   */
+  Load(S: HLRTopoBRep_OutLiner, SData: Standard_Transient, nbIso: number): void;
+  /**
+   * add the shape .
+   */
+  Load(S: HLRTopoBRep_OutLiner, nbIso: number): void;
+  /**
+   * return the index of the Shape and return 0 if the Shape is not found.
+   */
+  Index(S: HLRTopoBRep_OutLiner): number;
+  /**
+   * remove the Shape of Index *.*
+   */
+  Remove(I: number): void;
+  /**
+   * Change the Shape Data of the Shape of index *.*
+   */
+  ShapeData(I: number, SData: Standard_Transient): void;
+  SeqOfShapeBounds(): NCollection_Sequence_HLRBRep_ShapeBounds;
+  NbShapes(): number;
+  ShapeBounds(I: number): unknown;
+  /**
+   * init the status of the selected edges depending of the back faces of a closed shell.
+   */
+  InitEdgeStatus(): void;
+  /**
+   * select all the DataStructure.
+   */
+  Select(): void;
+  /**
+   * select only the Shape of index *.*
+   */
+  Select(I: number): void;
+  /**
+   * select only the edges of the Shape .
+   */
+  SelectEdge(I: number): void;
+  /**
+   * select only the faces of the Shape .
+   */
+  SelectFace(I: number): void;
+  /**
+   * set to visible all the edges.
+   */
+  ShowAll(): void;
+  /**
+   * set to visible all the edges of the Shape .
+   */
+  ShowAll(I: number): void;
+  /**
+   * set to hide all the edges.
+   */
+  HideAll(): void;
+  /**
+   * set to hide all the edges of the Shape .
+   */
+  HideAll(I: number): void;
+  /**
+   * own hiding of all the shapes of the DataStructure without hiding by each other.
+   */
+  PartialHide(): void;
+  /**
+   * hide all the DataStructure.
+   */
+  Hide(): void;
+  /**
+   * hide the Shape by itself.
+   */
+  Hide(I: number): void;
+  /**
+   * hide the Shape <S1> by the shape <S2>.
+   */
+  Hide(I: number, J: number): void;
+  Debug(deb: boolean): void;
+  Debug(): boolean;
+  static get_type_name(): string;
+  static get_type_descriptor(): unknown;
+  DynamicType(): unknown;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
+export type HLRBRep_TypeOfResultingEdge = typeof HLRBRep_TypeOfResultingEdge[keyof typeof HLRBRep_TypeOfResultingEdge];
+/**
+ * Identifies the type of resulting edge of {@link HLRBRep_Algo | `HLRBRep_Algo`}.
+ */
+export declare const HLRBRep_TypeOfResultingEdge: {
+  readonly HLRBRep_Undefined: 'HLRBRep_Undefined';
+  /**
+   * isoparametric line
+   */
+  readonly HLRBRep_IsoLine: 'HLRBRep_IsoLine';
+  /**
+   * outline ("silhouette")
+   */
+  readonly HLRBRep_OutLine: 'HLRBRep_OutLine';
+  /**
+   * smooth edge of G1-continuity between two surfaces
+   */
+  readonly HLRBRep_Rg1Line: 'HLRBRep_Rg1Line';
+  /**
+   * sewn edge of CN-continuity on one surface
+   */
+  readonly HLRBRep_RgNLine: 'HLRBRep_RgNLine';
+  /**
+   * sharp edge (of C0-continuity)
+   */
+  readonly HLRBRep_Sharp: 'HLRBRep_Sharp';
+};
+
+export declare class HLRTopoBRep_OutLiner extends Standard_Transient {
+  constructor();
+  constructor(OriSh: TopoDS_Shape);
+  constructor(OriS: TopoDS_Shape, OutS: TopoDS_Shape);
+  OriginalShape(OriS: TopoDS_Shape): void;
+  OriginalShape(): TopoDS_Shape;
+  OutLinedShape(OutS: TopoDS_Shape): void;
+  OutLinedShape(): TopoDS_Shape;
+  DataStructure(): unknown;
+  Fill(P: HLRAlgo_Projector, MST: NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher, nbIso: number): void;
+  static get_type_name(): string;
+  static get_type_descriptor(): unknown;
+  DynamicType(): unknown;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
 /**
  * Implementation of building helix wire Values of Error Status returned by algo: 0 - OK 1 - object is just initialized, it means that no input parameters were set 2 - approximation fails.
  *
@@ -17779,6 +18179,47 @@ export declare class ShapeAnalysis_WireOrder {
   [Symbol.dispose](): void;
 }
 
+/**
+ * This package is intended to convert geometrical objects and topological. The modifications of one geometrical object to another (one) geometrical object are provided.
+ * The supported modifications are the following: conversion of BSpline and Bezier surfaces to analytical form, conversion of indirect elementary surfaces (with left-handed coordinate systems) into direct ones, conversion of elementary surfaces to surfaces of revolution, conversion of surface of linear extrusion, revolution, offset surface to bspline, modification of parameterization, degree, number of segments of bspline surfaces, scale the shape.
+ */
+export declare class ShapeCustom {
+  constructor();
+  /**
+   * Applies modifier to shape and checks sharing in the case assemblies.
+   * @param context Mutated in place; read the updated value from this argument after the call.
+   */
+  static ApplyModifier(S: TopoDS_Shape, M: unknown, context: NCollection_DataMap_TopoDS_Shape_TopoDS_Shape_TopTools_ShapeMapHasher, MD: BRepTools_Modifier, theProgress: Message_ProgressRange, aReShape: unknown): TopoDS_Shape;
+  /**
+   * Returns a new shape without indirect surfaces.
+   */
+  static DirectFaces(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Returns a new shape which is scaled original.
+   */
+  static ScaleShape(S: TopoDS_Shape, scale: number): TopoDS_Shape;
+  /**
+   * Returns a new shape with all surfaces, curves and pcurves which type is BSpline/Bezier or based on them converted having Degree less than <MaxDegree> or number of spans less than <NbMaxSegment> in dependence on parameter priority <Degree>. <GmaxDegree> and <GMaxSegments> are maximum possible degree and number of spans correspondingly. These values will be used in those cases when approximation with specified parameters is impossible and one of GmaxDegree or GMaxSegments is selected in dependence on priority.
+   * Note that even if approximation is impossible with <GMaxDegree> then number of spans can exceed specified <GMaxSegment> <Rational> specifies if to convert Rational BSpline/Bezier into polynomial B-Spline. If flags ConvOffSurf,ConvOffCurve3d,ConvOffCurve2d are true there are means that Offset surfaces , Offset curves 3d and Offset curves 2d are converted to BSPline correspondingly.
+   */
+  static BSplineRestriction(S: TopoDS_Shape, Tol3d: number, Tol2d: number, MaxDegree: number, MaxNbSegment: number, Continuity3d: GeomAbs_Shape, Continuity2d: GeomAbs_Shape, Degree: boolean, Rational: boolean, aParameters: unknown): TopoDS_Shape;
+  /**
+   * Returns a new shape with all elementary periodic surfaces converted to {@link Geom_SurfaceOfRevolution | `Geom_SurfaceOfRevolution`}.
+   */
+  static ConvertToRevolution(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Returns a new shape with all surfaces of revolution and linear extrusion convert to elementary periodic surfaces.
+   */
+  static SweptToElementary(S: TopoDS_Shape): TopoDS_Shape;
+  /**
+   * Returns a new shape with all surfaces of linear extrusion, revolution, offset, and planar surfaces converted according to flags to {@link Geom_BSplineSurface | `Geom_BSplineSurface`} (with same parameterisation).
+   */
+  static ConvertToBSpline(S: TopoDS_Shape, extrMode: boolean, revolMode: boolean, offsetMode: boolean, planeMode?: boolean): TopoDS_Shape;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
 /**
  * This class provides a data structure necessary for work with the wire as with ordered list of edges, what is required for many algorithms. The advantage of this class is that it allows to work with wires which are not correct.
  * The object of the class {@link ShapeExtend_WireData | `ShapeExtend_WireData`} can be initialized by {@link TopoDS_Wire | `TopoDS_Wire`}, and converted back to {@link TopoDS_Wire | `TopoDS_Wire`}. An edge in the wire is defined by its rank number. Operations of accessing, adding and removing edge at the given rank number are provided.
@@ -21507,6 +21948,51 @@ export declare const BRepTools_History_TRelationType: {
   readonly TRelationType_Modified: 'TRelationType_Modified';
 };
 
+/**
+ * Performs geometric modifications on a shape.
+ */
+export declare class BRepTools_Modifier {
+  /**
+   * Creates an empty Modifier.
+   */
+  constructor(theMutableInput?: boolean);
+  /**
+   * Creates a modifier on the shape .
+   */
+  constructor(S: TopoDS_Shape);
+  /**
+   * Creates a modifier on the shape , and performs the modifications described by <M>.
+   */
+  constructor(S: TopoDS_Shape, M: unknown);
+  /**
+   * Initializes the modifier with the shape .
+   */
+  Init(S: TopoDS_Shape): void;
+  /**
+   * Performs the modifications described by <M>.
+   */
+  Perform(M: unknown, theProgress?: Message_ProgressRange): void;
+  /**
+   * Returns true if the modification has been computed successfully.
+   */
+  IsDone(): boolean;
+  /**
+   * Returns the current mutable input state.
+   */
+  IsMutableInput(): boolean;
+  /**
+   * Sets the mutable input state If true then the input (original) shape can be modified during modification process.
+   */
+  SetMutableInput(theMutableInput: boolean): void;
+  /**
+   * Returns the modified shape corresponding to .
+   */
+  ModifiedShape(S: TopoDS_Shape): TopoDS_Shape;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
 /**
  * The WireExplorer is a tool to explore the edges of a wire in a connection order.
  *
@@ -33635,6 +34121,113 @@ export declare class NCollection_DataMap_TDF_Label_TDF_Label extends NCollection
   [Symbol.dispose](): void;
 }
 
+/**
+ * Purpose: The DataMap is a Map to store keys with associated Items. See Map from NCollection for a discussion about the number of buckets.
+ *
+ * The DataMap can be seen as an extended array where the Keys are the indices. For this reason the operator () is defined on DataMap to fetch an Item from a Key. So the following syntax can be used :
+ *
+ * anItem = aMap(aKey); aMap(aKey) = anItem;
+ *
+ * This analogy has its limit. aMap(aKey) = anItem can be done only if aKey was previously bound to an item in the map.
+ */
+export declare class NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher extends NCollection_BaseMap {
+  /**
+   * Empty Constructor.
+   */
+  constructor();
+  /**
+   * Copy constructor.
+   */
+  constructor(theOther: NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher);
+  /**
+   * Constructor.
+   */
+  constructor(theNbBuckets: number, theAllocator?: unknown);
+  /**
+   * Constructor with custom hasher (copy).
+   * @param theHasher custom hasher instance
+   * @param theNbBuckets initial number of buckets
+   * @param theAllocator custom memory allocator
+   */
+  constructor(theHasher: unknown, theNbBuckets?: number, theAllocator?: unknown);
+  /**
+   * Exchange the content of two maps without re-allocations. Notice that allocators will be swapped as well!
+   * @param theOther Mutated in place; read the updated value from this argument after the call.
+   */
+  Exchange(theOther: NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher): void;
+  /**
+   * Returns const reference to the hasher.
+   */
+  GetHasher(): unknown;
+  /**
+   * Assignment. This method does not change the internal allocator.
+   */
+  Assign(theOther: NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher): NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher;
+  /**
+   * ReSize.
+   */
+  ReSize(N: number): void;
+  /**
+   * Bind binds Item to Key in map.
+   * @param theKey key to add/update
+   * @param theItem new item; overrides value previously bound to the key (uses destroy+reconstruct)
+   * @returns true if Key was not bound already
+   */
+  Bind(theKey: TopoDS_Shape, theItem: unknown): boolean;
+  /**
+   * Bound binds Item to Key in map.
+   * @param theKey key to add/update
+   * @param theItem new item; overrides value previously bound to the key (uses destroy+reconstruct)
+   * @returns pointer to modifiable Item
+   */
+  Bound(theKey: TopoDS_Shape, theItem: unknown): unknown;
+  /**
+   * TryBind binds Item to Key in map only if Key is not yet bound.
+   * @param theKey key to add
+   * @param theItem item to bind if Key is not yet bound
+   * @returns true if Key was newly bound, false if Key already existed (no replacement)
+   */
+  TryBind(theKey: TopoDS_Shape, theItem: unknown): boolean;
+  /**
+   * TryBound binds Item to Key in map only if Key is not yet bound.
+   * @param theKey key to add
+   * @param theItem item to bind if Key is not yet bound
+   * @returns reference to existing or newly bound Item
+   */
+  TryBound(theKey: TopoDS_Shape, theItem: unknown): unknown;
+  /**
+   * IsBound.
+   */
+  IsBound(theKey: TopoDS_Shape): boolean;
+  /**
+   * UnBind removes Item Key pair from map.
+   */
+  UnBind(theKey: TopoDS_Shape): boolean;
+  /**
+   * Seek returns pointer to Item by Key. Returns NULL is Key was not bound.
+   */
+  Seek(theKey: TopoDS_Shape): unknown;
+  /**
+   * ChangeSeek returns modifiable pointer to Item by Key. Returns NULL is Key was not bound.
+   */
+  ChangeSeek(theKey: TopoDS_Shape): unknown;
+  /**
+   * ChangeFind returns modifiable Item by Key. Raises if Key was not bound.
+   */
+  ChangeFind(theKey: TopoDS_Shape): unknown;
+  /**
+   * Clear data. If doReleaseMemory is false then the table of buckets is not released and will be reused.
+   */
+  Clear(doReleaseMemory: boolean): void;
+  /**
+   * Clear data and reset allocator.
+   */
+  Clear(theAllocator: unknown): void;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
 /**
  * Purpose: The DataMap is a Map to store keys with associated Items. See Map from NCollection for a discussion about the number of buckets.
  *
@@ -38301,6 +38894,141 @@ export declare class NCollection_Sequence_Extrema_POnCurv extends NCollection_Ba
   [Symbol.dispose](): void;
 }
 
+/**
+ * Purpose: Definition of a sequence of elements indexed by an Integer in range of 1..n
+ */
+export declare class NCollection_Sequence_HLRBRep_ShapeBounds extends NCollection_BaseSequence {
+  /**
+   * Empty constructor.
+   */
+  constructor();
+  /**
+   * Constructor.
+   */
+  constructor(theAllocator: unknown);
+  /**
+   * Copy constructor.
+   */
+  constructor(theOther: NCollection_Sequence_HLRBRep_ShapeBounds);
+  // dropped: delNode param 0 resolves to excluded type NCollection_SeqNode
+  /**
+   * Method for consistency with other collections.
+   * @returns Lower bound (inclusive) for iteration.
+   */
+  static Lower(): number;
+  /**
+   * Method for consistency with other collections.
+   * @returns Upper bound (inclusive) for iteration.
+   */
+  Upper(): number;
+  /**
+   * Empty query.
+   */
+  IsEmpty(): boolean;
+  /**
+   * Reverse sequence.
+   */
+  Reverse(): void;
+  /**
+   * Exchange two members.
+   */
+  Exchange(I: number, J: number): void;
+  /**
+   * Clear the items out, take a new allocator if non null.
+   */
+  Clear(theAllocator?: unknown): void;
+  /**
+   * Replace this sequence by the items of theOther. This method does not change the internal allocator.
+   */
+  Assign(theOther: NCollection_Sequence_HLRBRep_ShapeBounds): NCollection_Sequence_HLRBRep_ShapeBounds;
+  /**
+   * Remove one item.
+   */
+  Remove(theIndex: number): void;
+  /**
+   * Remove range of items.
+   */
+  Remove(theFromIndex: number, theToIndex: number): void;
+  /**
+   * Append one item.
+   */
+  Append(theItem: unknown): void;
+  /**
+   * Append one item.
+   * @param theSeq Mutated in place; read the updated value from this argument after the call.
+   */
+  Append(theSeq: NCollection_Sequence_HLRBRep_ShapeBounds): void;
+  /**
+   * Prepend one item.
+   */
+  Prepend(theItem: unknown): void;
+  /**
+   * Prepend one item.
+   * @param theSeq Mutated in place; read the updated value from this argument after the call.
+   */
+  Prepend(theSeq: NCollection_Sequence_HLRBRep_ShapeBounds): void;
+  /**
+   * InsertBefore theIndex theItem.
+   */
+  InsertBefore(theIndex: number, theItem: unknown): void;
+  InsertBefore(theIndex: number, theSeq: NCollection_Sequence_HLRBRep_ShapeBounds): void;
+  /**
+   * InsertAfter the position of iterator.
+   * @param theSeq Mutated in place; read the updated value from this argument after the call.
+   */
+  InsertAfter(theIndex: number, theSeq: NCollection_Sequence_HLRBRep_ShapeBounds): void;
+  /**
+   * InsertAfter the position of iterator.
+   */
+  InsertAfter(theIndex: number, theItem: unknown): void;
+  /**
+   * Split in two sequences.
+   * @param theSeq Mutated in place; read the updated value from this argument after the call.
+   */
+  Split(theIndex: number, theSeq: NCollection_Sequence_HLRBRep_ShapeBounds): void;
+  /**
+   * First item access.
+   */
+  First(): unknown;
+  /**
+   * First item access.
+   */
+  ChangeFirst(): unknown;
+  /**
+   * Last item access.
+   */
+  Last(): unknown;
+  /**
+   * Last item access.
+   */
+  ChangeLast(): unknown;
+  /**
+   * Constant item access by theIndex.
+   */
+  Value(theIndex: number): unknown;
+  /**
+   * Variable item access by theIndex.
+   */
+  ChangeValue(theIndex: number): unknown;
+  /**
+   * Set item value by theIndex.
+   */
+  SetValue(theIndex: number, theItem: unknown): void;
+  /**
+   * 0-based checked access independent of `Lower()`/Upper().
+   * @param theIndex 0-based index in [0, `Size()`-1]
+   */
+  At(theIndex: number): unknown;
+  /**
+   * 0-based checked mutable access independent of `Lower()`/Upper().
+   * @param theIndex 0-based index in [0, `Size()`-1]
+   */
+  ChangeAt(theIndex: number): unknown;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
 /**
  * Purpose: Definition of a sequence of elements indexed by an Integer in range of 1..n
  */
@@ -41052,6 +41780,14 @@ export declare class BRep_ToolExt {
   [Symbol.dispose](): void;
 }
 
+export declare class ShapeCustomExt {
+  constructor();
+  static DirectFaces(S: TopoDS_Shape, MD: BRepTools_Modifier): TopoDS_Shape;
+  /** Releases the C++ object. The caller must ensure no further access. */
+  delete(): void;
+  [Symbol.dispose](): void;
+}
+
 /**
  * Indexed map of ASCII string key-value pairs.
  *
@@ -41756,9 +42492,11 @@ export type BOPDS_VectorOfInterfVV = NCollection_DynamicArray_BOPDS_InterfVV;
 export type BOPDS_VectorOfInterfVZ = NCollection_DynamicArray_BOPDS_InterfVZ;
 export type BOPDS_VectorOfInterfZZ = NCollection_DynamicArray_BOPDS_InterfZZ;
 export type BRepCheck_ListOfStatus = NCollection_List_BRepCheck_Status;
+export type BRepTopAdaptor_MapOfShapeTool = NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher;
 export type ChFiDS_SecArray1 = NCollection_Array1_ChFiDS_CircSection;
 export type ChFiDS_SecHArray1 = NCollection_HArray1_ChFiDS_CircSection;
 export type Extrema_SequenceOfPOnCurv = NCollection_Sequence_Extrema_POnCurv;
+export type HLRBRep_SeqOfShapeBounds = NCollection_Sequence_HLRBRep_ShapeBounds;
 export type IntRes2d_SequenceOfIntersectionPoint = NCollection_Sequence_IntRes2d_IntersectionPoint;
 export type IntSurf_ListOfPntOn2S = NCollection_List_IntSurf_PntOn2S;
 export type IntTools_ListOfSurfaceRangeSample = NCollection_List_IntTools_SurfaceRangeSample;
@@ -41993,6 +42731,12 @@ export type OpenCascadeInstance = {
   Geom2dGcc_QualifiedCurve: typeof Geom2dGcc_QualifiedCurve;
   GeomAPI: typeof GeomAPI;
   Law_Function: typeof Law_Function;
+  HLRAlgo_Projector: typeof HLRAlgo_Projector;
+  HLRBRep_Algo: typeof HLRBRep_Algo;
+  HLRBRep_HLRToShape: typeof HLRBRep_HLRToShape;
+  HLRBRep_InternalAlgo: typeof HLRBRep_InternalAlgo;
+  HLRBRep_TypeOfResultingEdge: typeof HLRBRep_TypeOfResultingEdge;
+  HLRTopoBRep_OutLiner: typeof HLRTopoBRep_OutLiner;
   HelixBRep_BuilderHelix: typeof HelixBRep_BuilderHelix;
   HelixGeom_BuilderApproxCurve: typeof HelixGeom_BuilderApproxCurve;
   HelixGeom_BuilderHelix: typeof HelixGeom_BuilderHelix;
@@ -42023,6 +42767,7 @@ export type OpenCascadeInstance = {
   BRepSweep_Revol: typeof BRepSweep_Revol;
   ShapeAnalysis_FreeBounds: typeof ShapeAnalysis_FreeBounds;
   ShapeAnalysis_WireOrder: typeof ShapeAnalysis_WireOrder;
+  ShapeCustom: typeof ShapeCustom;
   ShapeExtend_WireData: typeof ShapeExtend_WireData;
   ShapeFix_Face: typeof ShapeFix_Face;
   ShapeFix_Root: typeof ShapeFix_Root;
@@ -42065,6 +42810,7 @@ export type OpenCascadeInstance = {
   BRepTools: typeof BRepTools;
   BRepTools_History: typeof BRepTools_History;
   BRepTools_History_TRelationType: typeof BRepTools_History_TRelationType;
+  BRepTools_Modifier: typeof BRepTools_Modifier;
   BRepTools_WireExplorer: typeof BRepTools_WireExplorer;
   TopExp: typeof TopExp;
   TopExp_Explorer: typeof TopExp_Explorer;
@@ -42177,6 +42923,7 @@ export type OpenCascadeInstance = {
   NCollection_DataMap_TCollection_ExtendedString_handle_NCollection_HArray1_int: typeof NCollection_DataMap_TCollection_ExtendedString_handle_NCollection_HArray1_int;
   NCollection_DataMap_TCollection_ExtendedString_int: typeof NCollection_DataMap_TCollection_ExtendedString_int;
   NCollection_DataMap_TDF_Label_TDF_Label: typeof NCollection_DataMap_TDF_Label_TDF_Label;
+  NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher: typeof NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher;
   NCollection_DataMap_TopoDS_Shape_NCollection_List_TopoDS_Shape_TopTools_ShapeMapHasher: typeof NCollection_DataMap_TopoDS_Shape_NCollection_List_TopoDS_Shape_TopTools_ShapeMapHasher;
   NCollection_DataMap_TopoDS_Shape_TDF_Label_TopTools_ShapeMapHasher: typeof NCollection_DataMap_TopoDS_Shape_TDF_Label_TopTools_ShapeMapHasher;
   NCollection_DataMap_TopoDS_Shape_TopoDS_Shape_TopTools_ShapeMapHasher: typeof NCollection_DataMap_TopoDS_Shape_TopoDS_Shape_TopTools_ShapeMapHasher;
@@ -42239,6 +42986,7 @@ export type OpenCascadeInstance = {
   NCollection_Map_handle_TDF_Attribute: typeof NCollection_Map_handle_TDF_Attribute;
   NCollection_Map_int: typeof NCollection_Map_int;
   NCollection_Sequence_Extrema_POnCurv: typeof NCollection_Sequence_Extrema_POnCurv;
+  NCollection_Sequence_HLRBRep_ShapeBounds: typeof NCollection_Sequence_HLRBRep_ShapeBounds;
   NCollection_Sequence_IntRes2d_IntersectionPoint: typeof NCollection_Sequence_IntRes2d_IntersectionPoint;
   NCollection_Sequence_IntTools_CommonPrt: typeof NCollection_Sequence_IntTools_CommonPrt;
   NCollection_Sequence_IntTools_Curve: typeof NCollection_Sequence_IntTools_Curve;
@@ -42260,6 +43008,7 @@ export type OpenCascadeInstance = {
   math_VectorBase_double: typeof math_VectorBase_double;
   NCollection_DataMap_TCollection_ExtendedString_unsignedchar: typeof NCollection_DataMap_TCollection_ExtendedString_unsignedchar;
   BRep_ToolExt: typeof BRep_ToolExt;
+  ShapeCustomExt: typeof ShapeCustomExt;
   TColStd_IndexedDataMapOfStringString: typeof TColStd_IndexedDataMapOfStringString;
   TopoDS: typeof TopoDS;
   OCJS: typeof OCJS;
@@ -42279,9 +43028,11 @@ export type OpenCascadeInstance = {
   /* deprecated-name alias */ BOPDS_VectorOfInterfVZ: typeof NCollection_DynamicArray_BOPDS_InterfVZ;
   /* deprecated-name alias */ BOPDS_VectorOfInterfZZ: typeof NCollection_DynamicArray_BOPDS_InterfZZ;
   /* deprecated-name alias */ BRepCheck_ListOfStatus: typeof NCollection_List_BRepCheck_Status;
+  /* deprecated-name alias */ BRepTopAdaptor_MapOfShapeTool: typeof NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher;
   /* deprecated-name alias */ ChFiDS_SecArray1: typeof NCollection_Array1_ChFiDS_CircSection;
   /* deprecated-name alias */ ChFiDS_SecHArray1: typeof NCollection_HArray1_ChFiDS_CircSection;
   /* deprecated-name alias */ Extrema_SequenceOfPOnCurv: typeof NCollection_Sequence_Extrema_POnCurv;
+  /* deprecated-name alias */ HLRBRep_SeqOfShapeBounds: typeof NCollection_Sequence_HLRBRep_ShapeBounds;
   /* deprecated-name alias */ IntRes2d_SequenceOfIntersectionPoint: typeof NCollection_Sequence_IntRes2d_IntersectionPoint;
   /* deprecated-name alias */ IntSurf_ListOfPntOn2S: typeof NCollection_List_IntSurf_PntOn2S;
   /* deprecated-name alias */ IntTools_ListOfSurfaceRangeSample: typeof NCollection_List_IntTools_SurfaceRangeSample;
@@ -42372,9 +43123,11 @@ export type BOPDS_VectorOfInterfVV = NCollection_DynamicArray_BOPDS_InterfVV;
 export type BOPDS_VectorOfInterfVZ = NCollection_DynamicArray_BOPDS_InterfVZ;
 export type BOPDS_VectorOfInterfZZ = NCollection_DynamicArray_BOPDS_InterfZZ;
 export type BRepCheck_ListOfStatus = NCollection_List_BRepCheck_Status;
+export type BRepTopAdaptor_MapOfShapeTool = NCollection_DataMap_TopoDS_Shape_BRepTopAdaptor_Tool_TopTools_ShapeMapHasher;
 export type ChFiDS_SecArray1 = NCollection_Array1_ChFiDS_CircSection;
 export type ChFiDS_SecHArray1 = NCollection_HArray1_ChFiDS_CircSection;
 export type Extrema_SequenceOfPOnCurv = NCollection_Sequence_Extrema_POnCurv;
+export type HLRBRep_SeqOfShapeBounds = NCollection_Sequence_HLRBRep_ShapeBounds;
 export type IntRes2d_SequenceOfIntersectionPoint = NCollection_Sequence_IntRes2d_IntersectionPoint;
 export type IntSurf_ListOfPntOn2S = NCollection_List_IntSurf_PntOn2S;
 export type IntTools_ListOfSurfaceRangeSample = NCollection_List_IntTools_SurfaceRangeSample;