// tslint:disable-next-line: no-namespace
export var OCCT;
(function (OCCT) {
    let JoinTypeEnum;
    (function (JoinTypeEnum) {
        JoinTypeEnum["arc"] = "arc";
        JoinTypeEnum["intersection"] = "intersection";
        JoinTypeEnum["tangent"] = "tangent";
    })(JoinTypeEnum = OCCT.JoinTypeEnum || (OCCT.JoinTypeEnum = {}));
    let BRepOffsetModeEnum;
    (function (BRepOffsetModeEnum) {
        BRepOffsetModeEnum["skin"] = "skin";
        BRepOffsetModeEnum["pipe"] = "pipe";
        BRepOffsetModeEnum["rectoVerso"] = "rectoVerso";
    })(BRepOffsetModeEnum = OCCT.BRepOffsetModeEnum || (OCCT.BRepOffsetModeEnum = {}));
    let ApproxParametrizationTypeEnum;
    (function (ApproxParametrizationTypeEnum) {
        ApproxParametrizationTypeEnum["approxChordLength"] = "approxChordLength";
        ApproxParametrizationTypeEnum["approxCentripetal"] = "approxCentripetal";
        ApproxParametrizationTypeEnum["approxIsoParametric"] = "approxIsoParametric";
    })(ApproxParametrizationTypeEnum = OCCT.ApproxParametrizationTypeEnum || (OCCT.ApproxParametrizationTypeEnum = {}));
    let directionEnum;
    (function (directionEnum) {
        directionEnum["outside"] = "outside";
        directionEnum["inside"] = "inside";
        directionEnum["middle"] = "middle";
    })(directionEnum = OCCT.directionEnum || (OCCT.directionEnum = {}));
    class DecomposedMeshDto {
    }
    OCCT.DecomposedMeshDto = DecomposedMeshDto;
    class DecomposedFaceDto {
    }
    OCCT.DecomposedFaceDto = DecomposedFaceDto;
    class DecomposedEdgeDto {
    }
    OCCT.DecomposedEdgeDto = DecomposedEdgeDto;
    class ShapesDto {
        constructor(shapes) {
            this.shapes = shapes;
        }
    }
    OCCT.ShapesDto = ShapesDto;
    class FilletTwoEdgesInPlaneDto extends ShapesDto {
        constructor() {
            super(...arguments);
            /**
             * Plane origin that is also used to find the closest solution if two solutions exist.
             * @default [0, 0, 0]
             */
            this.planeOrigin = [0, 0, 0];
            /**
             * Plane direction for fillet
             * @default [0, 1, 0]
             */
            this.planeDirection = [0, 1, 0];
            /**
             * Radius of the fillet
             * @default 0.3
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius = 0.3;
            /**
             * if solution is -1 planeOrigin chooses a particular fillet in case of several fillets may be constructed (for example, a circle intersecting a segment in 2 points). Put the intersecting (or common) point of the edges
             * @default -1
             * @optional true
             */
            this.solution = -1;
        }
    }
    OCCT.FilletTwoEdgesInPlaneDto = FilletTwoEdgesInPlaneDto;
    class ClosestPointsOnShapeFromPointsDto {
    }
    OCCT.ClosestPointsOnShapeFromPointsDto = ClosestPointsOnShapeFromPointsDto;
    class ClosestPointsOnShapesFromPointsDto {
    }
    OCCT.ClosestPointsOnShapesFromPointsDto = ClosestPointsOnShapesFromPointsDto;
    class ClosestPointsBetweenTwoShapesDto extends ShapesDto {
        constructor(shape1, shape2) {
            if (shape1 && shape2) {
                super([shape1, shape2]);
            }
        }
    }
    OCCT.ClosestPointsBetweenTwoShapesDto = ClosestPointsBetweenTwoShapesDto;
    class FaceFromSurfaceAndWireDto extends ShapesDto {
        constructor() {
            super(...arguments);
            /**
             * Indicates wether face should be created inside or outside the wire
             * @default true
             */
            this.inside = true;
        }
    }
    OCCT.FaceFromSurfaceAndWireDto = FaceFromSurfaceAndWireDto;
    class EdgeFromGeom2dCurveAndSurfaceDto extends ShapesDto {
    }
    OCCT.EdgeFromGeom2dCurveAndSurfaceDto = EdgeFromGeom2dCurveAndSurfaceDto;
    class WireOnFaceDto extends ShapesDto {
    }
    OCCT.WireOnFaceDto = WireOnFaceDto;
    class DrawShapeDto {
        /**
         * Provide options without default values
         */
        constructor(shape) {
            /**
             * Face opacity value between 0 and 1
             * @default 1
             * @minimum 0
             * @maximum 1
             * @step 0.1
             */
            this.faceOpacity = 1;
            /**
             * Edge opacity value between 0 and 1
             * @default 1
             * @minimum 0
             * @maximum 1
             * @step 0.1
             */
            this.edgeOpacity = 1;
            /**
             * Hex colour string for the edges
             * @default #ffffff
             */
            this.edgeColour = "#ffffff";
            /**
             * Hex colour string for face colour
             * @default #ff0000
             */
            this.faceColour = "#ff0000";
            /**
             * Edge width
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.edgeWidth = 2;
            /**
             * You can turn off drawing of edges via this property
             * @default true
             */
            this.drawEdges = true;
            /**
             * You can turn off drawing of faces via this property
             * @default true
             */
            this.drawFaces = true;
            /**
             * Precision of the mesh that will be generated for the shape, lower number will mean more triangles
             * @default 0.01
             * @minimum 0
             * @maximum Infinity
             * @step 0.01
             */
            this.precision = 0.01;
            /**
             * Draw index of edges in space
             * @default false
             */
            this.drawEdgeIndexes = false;
            /**
             * Indicates the edge index height if they are drawn
             * @default 0.06
             * @minimum 0
             * @maximum Infinity
             * @step 0.01
             */
            this.edgeIndexHeight = 0.06;
            /**
             * Edge index colour if the edges are drawn
             * @default #ff00ff
             */
            this.edgeIndexColour = "#ff00ff";
            /**
             * Draw indexes of faces in space
             * @default false
             */
            this.drawFaceIndexes = false;
            /**
             * Indicates the edge index height if they are drawn
             * @default 0.06
             * @minimum 0
             * @maximum Infinity
             * @step 0.01
             */
            this.faceIndexHeight = 0.06;
            /**
             * Edge index colour if the edges are drawn
             * @default #0000ff
             */
            this.faceIndexColour = "#0000ff";
            this.shape = shape;
        }
    }
    OCCT.DrawShapeDto = DrawShapeDto;
    class FaceSubdivisionDto {
        /**
          * Provide options without default values
          */
        constructor(shape) {
            /**
             * Number of subdivisions on U direction
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrDivisionsU = 10;
            /**
             * Number of subdivisions on V direction
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrDivisionsV = 10;
            /**
             * Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
             * @default false
             */
            this.shiftHalfStepU = false;
            /**
             * Removes start edge points on U
             * @default false
             */
            this.removeStartEdgeU = false;
            /**
             * Removes end edge points on U
             * @default false
             */
            this.removeEndEdgeU = false;
            /**
             * Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
             * @default false
             */
            this.shiftHalfStepV = false;
            /**
             * Removes start edge points on V
             * @default false
             */
            this.removeStartEdgeV = false;
            /**
             * Removes end edge points on V
             * @default false
             */
            this.removeEndEdgeV = false;
            this.shape = shape;
        }
    }
    OCCT.FaceSubdivisionDto = FaceSubdivisionDto;
    class FaceSubdivisionControlledDto {
        /**
         * Provide options without default values
         */
        constructor(shape) {
            /**
             * Number of subdivisions on U direction
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrDivisionsU = 10;
            /**
             * Number of subdivisions on V direction
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrDivisionsV = 10;
            /**
             * Shift half step every nth U row
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.shiftHalfStepNthU = 0;
            /**
             * Offset for shift half step every nth U row
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.shiftHalfStepUOffsetN = 0;
            /**
             * Removes start edge points on U
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeStartEdgeNthU = 0;
            /**
             * Offset for remove start edge points on U
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeStartEdgeUOffsetN = 0;
            /**
             * Removes end edge points on U
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeEndEdgeNthU = 0;
            /**
             * Offset for remove end edge points on U
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeEndEdgeUOffsetN = 0;
            /**
             * Shift half step every nth V row
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.shiftHalfStepNthV = 0;
            /**
             * Offset for shift half step every nth V row
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.shiftHalfStepVOffsetN = 0;
            /**
             * Removes start edge points on V
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeStartEdgeNthV = 0;
            /**
             * Offset for remove start edge points on V
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeStartEdgeVOffsetN = 0;
            /**
             * Removes end edge points on V
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeEndEdgeNthV = 0;
            /**
             * Offset for remove end edge points on V
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.removeEndEdgeVOffsetN = 0;
            this.shape = shape;
        }
    }
    OCCT.FaceSubdivisionControlledDto = FaceSubdivisionControlledDto;
    class FaceLinearSubdivisionDto {
        /**
         * Provide options without default values
         */
        constructor(shape) {
            /**
             * Linear subdivision direction true - U, false - V
             * @default true
             */
            this.isU = true;
            /**
             * Param on direction 0 - 1
             * @default 0.5
             * @minimum 0
             * @maximum 1
             * @step 0.1
             */
            this.param = 0.5;
            /**
             * Number of subdivisions on opposite direction
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrPoints = 10;
            /**
             * Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
             * @default false
             */
            this.shiftHalfStep = false;
            /**
             * Removes first point
             * @default false
             */
            this.removeStartPoint = false;
            /**
             * Removes last point
             * @default false
             */
            this.removeEndPoint = false;
            this.shape = shape;
        }
    }
    OCCT.FaceLinearSubdivisionDto = FaceLinearSubdivisionDto;
    class DataOnUVDto {
        /**
         * Provide options without default values
         */
        constructor(shape) {
            /**
             * Param on U direction 0 to 1
             * @default 0.5
             * @minimum 0
             * @maximum 1
             * @step 0.1
             */
            this.paramU = 0.5;
            /**
             * Param on V direction 0 to 1
             * @default 0.5
             * @minimum 0
             * @maximum 1
             * @step 0.1
             */
            this.paramV = 0.5;
            this.shape = shape;
        }
    }
    OCCT.DataOnUVDto = DataOnUVDto;
    class DataOnUVsDto {
        /**
         * Provide options without default values
         */
        constructor(shape) {
            /**
             * Params uv
             * @default [[0.5, 0.5]]
             */
            this.paramsUV = [[0.5, 0.5]];
            this.shape = shape;
        }
    }
    OCCT.DataOnUVsDto = DataOnUVsDto;
    class PolygonDto {
        constructor(points) {
            this.points = points;
        }
    }
    OCCT.PolygonDto = PolygonDto;
    class PolylineDto {
        constructor(points) {
            this.points = points;
        }
    }
    OCCT.PolylineDto = PolylineDto;
    class SquareDto {
        constructor() {
            /**
             * size of square
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.size = 1;
            /**
             * Center of the square
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction of the square
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
        }
    }
    OCCT.SquareDto = SquareDto;
    class RectangleDto {
        constructor() {
            /**
             * width of the rectangle
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.width = 1;
            /**
             * Height of the rectangle
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.length = 2;
            /**
             * Center of the rectangle
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction of the rectangle
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
        }
    }
    OCCT.RectangleDto = RectangleDto;
    class LPolygonDto {
        constructor() {
            /**
             * Width of the first side of L polygon
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.widthFirst = 1;
            /**
             * Length of the first side of L polygon
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.lengthFirst = 2;
            /**
             * Width of the second side of L polygon
             * @default 0.5
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.widthSecond = 0.5;
            /**
             * Length of the second side of L polygon
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.lengthSecond = 2;
            /**
             * Indicates if the L polygon should be aligned inside/outside or middle
             * @default outside
             */
            this.align = directionEnum.outside;
            /**
             * Rotation of the L polygon
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 15
             */
            this.rotation = 0;
            /**
             * Center of the L polygon
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction of the  L polygon
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
        }
    }
    OCCT.LPolygonDto = LPolygonDto;
    class BoxDto {
        constructor(width, length, height, center) {
            /**
             * Width of the box
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.width = 1;
            /**
             * Length of the box
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.length = 2;
            /**
             * Height of the box
             * @default 3
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.height = 3;
            /**
             * Center of the box
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            this.width = width;
            this.length = length;
            this.height = height;
            if (center) {
                this.center = center;
            }
        }
    }
    OCCT.BoxDto = BoxDto;
    class BoxFromCornerDto {
        constructor(width, length, height, corner) {
            /**
             * Width of the box
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.width = 1;
            /**
             * Length of the box
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.length = 2;
            /**
             * Height of the box
             * @default 3
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.height = 3;
            /**
             * Corner of the box
             * @default [0, 0, 0]
             */
            this.corner = [0, 0, 0];
            this.width = width;
            this.length = length;
            this.height = height;
            if (corner) {
                this.corner = corner;
            }
        }
    }
    OCCT.BoxFromCornerDto = BoxFromCornerDto;
    class SphereDto {
        constructor(radius, center) {
            /**
             * Radius of the sphere
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius = 1;
            /**
             * Center of the sphere
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            this.radius = radius;
            if (center) {
                this.center = center;
            }
        }
    }
    OCCT.SphereDto = SphereDto;
    class ConeDto {
        constructor(radius1, radius2, height, angle, center, direction) {
            /**
             * First radius of the cone
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius1 = 2;
            /**
             * Second radius of the cone
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius2 = 1;
            /**
             * Height of the cone
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.height = 2;
            /**
             * Angle of the cone
             * @default 360
             * @minimum 0
             * @maximum 360
             * @step 1
             */
            this.angle = 360;
            /**
             * Center of the cone
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction of the cone
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            this.radius1 = radius1;
            this.radius2 = radius2;
            this.height = height;
            this.angle = angle;
            this.center = center;
            this.direction = direction;
        }
    }
    OCCT.ConeDto = ConeDto;
    class LineDto {
        constructor() {
            /**
             * Start of the line
             * @default [0, 0, 0]
             */
            this.start = [0, 0, 0];
            /**
             * End of the line
             * @default [0, 1, 0]
             */
            this.end = [0, 1, 0];
        }
    }
    OCCT.LineDto = LineDto;
    class ArcEdgeThreePointsDto {
        constructor() {
            /**
             * Start of the arc
             * @default [0, 0, 0]
             */
            this.start = [0, 0, 0];
            /**
            * Middle of the arc
            * @default [0, 1, 0]
            */
            this.middle = [0, 1, 0];
            /**
             * End of the arc
             * @default [0, 0, 1]
             */
            this.end = [0, 0, 1];
        }
    }
    OCCT.ArcEdgeThreePointsDto = ArcEdgeThreePointsDto;
    class CylinderDto {
        constructor() {
            /**
             * Radius of the cylinder
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius = 1;
            /**
             * Height of the cylinder
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.height = 2;
            /**
             * Center of the cylinder
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction for the cylinder
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
        }
    }
    OCCT.CylinderDto = CylinderDto;
    class CylindersOnLinesDto {
    }
    OCCT.CylindersOnLinesDto = CylindersOnLinesDto;
    class FilletDto {
        constructor(shape, radius, indexes) {
            /**
             * Radius of the fillets
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             * @optional true
             */
            this.radius = 0.1;
            this.shape = shape;
            this.radius = radius;
            this.indexes = indexes;
        }
    }
    OCCT.FilletDto = FilletDto;
    class Fillet3DWireDto {
        constructor(shape) {
            /**
             * Radius of the fillets
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             * @optional true
             */
            this.radius = 0.1;
            /**
             * Orientation direction for the fillet
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            this.shape = shape;
        }
    }
    OCCT.Fillet3DWireDto = Fillet3DWireDto;
    class ChamferDto {
        constructor(shape, distance, indexes) {
            /**
             * Distance for the chamfer
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @optional true
             * @step 0.1
             */
            this.distance = 0.1;
            this.shape = shape;
            this.distance = distance;
            this.indexes = indexes;
        }
    }
    OCCT.ChamferDto = ChamferDto;
    class BSplineDto {
        constructor(points, closed) {
            /**
             * Indicates wether BSpline will be cloed
             * @default false
             */
            this.closed = false;
            this.points = points;
            this.closed = closed;
        }
    }
    OCCT.BSplineDto = BSplineDto;
    class InterpolationDto {
        constructor(points, periodic) {
            /**
             * Indicates wether BSpline will be periodic
             * @default false
             */
            this.periodic = false;
            /**
             * tolerance
             * @default 1e-7
             * @minimum 0
             * @maximum Infinity
             * @step 0.00001
             */
            this.tolerance = 1e-7;
            this.points = points;
            this.periodic = periodic;
        }
    }
    OCCT.InterpolationDto = InterpolationDto;
    class BezierDto {
        constructor(points, closed) {
            /**
             * Indicates wether Bezier will be cloed
             * @default false
             */
            this.closed = false;
            this.points = points;
            this.closed = closed;
        }
    }
    OCCT.BezierDto = BezierDto;
    class DivideDto {
        constructor(shape, nrOfDivisions, removeStartPoint, removeEndPoint) {
            /**
             * The number of divisions that will be performed on the curve
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrOfDivisions = 10;
            /**
             * Indicates if algorithm should remove start point
             * @default false
             */
            this.removeStartPoint = false;
            /**
             * Indicates if algorithm should remove end point
             * @default false
             */
            this.removeEndPoint = false;
            this.shape = shape;
            this.nrOfDivisions = nrOfDivisions;
            this.removeStartPoint = removeStartPoint;
            this.removeEndPoint = removeEndPoint;
        }
    }
    OCCT.DivideDto = DivideDto;
    class DataOnGeometryAtParamDto {
        constructor(shape, param) {
            /**
             * 0 - 1 value
             * @default 0.5
             * @minimum 0
             * @maximum 1
             * @step 0.1
             */
            this.param = 0.5;
            this.shape = shape;
            this.param = param;
        }
    }
    OCCT.DataOnGeometryAtParamDto = DataOnGeometryAtParamDto;
    class PointInFaceDto extends ShapesDto {
        constructor(face, edge, tEdgeParam, distance2DParam) {
            super();
            /**
             * 0 - 1 value
             * @default 0.5
             * @minimum 0
             * @maximum 1
             * @step 0.1
             */
            this.tEdgeParam = 0.5;
            /**
             * The point will be distanced on <distance2DParam> from the 2d curve.
             * @default 0.5
             * @minimum -Infinity
             * @maximum Infinity
             * @step 0.1
             */
            this.distance2DParam = 0.5;
            this.face = face;
            this.edge = edge;
            this.tEdgeParam = tEdgeParam;
            this.distance2DParam = distance2DParam;
        }
    }
    OCCT.PointInFaceDto = PointInFaceDto;
    class DataOnGeometryAtLengthDto {
        constructor(shape, length) {
            /**
             * length at which to evaluate the point
             * @default 0.5
             * @minimum -Infinity
             * @maximum Infinity
             * @step 0.1
             */
            this.length = 0.5;
            this.shape = shape;
            this.length = length;
        }
    }
    OCCT.DataOnGeometryAtLengthDto = DataOnGeometryAtLengthDto;
    class CircleDto {
        constructor(radius, center, direction) {
            /**
             * Radius of the circle
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius = 1;
            /**
             * Center of the circle
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction vector for circle
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            this.radius = radius;
            this.center = center;
            this.direction = direction;
        }
    }
    OCCT.CircleDto = CircleDto;
    class LoftDto {
        constructor(shapes, makeSolid) {
            /**
             * Tries to make a solid when lofting
             * @default false
             */
            this.makeSolid = false;
            this.shapes = shapes;
            this.makeSolid = makeSolid;
        }
    }
    OCCT.LoftDto = LoftDto;
    class LoftAdvancedDto {
        constructor(shapes) {
            /**
             * Tries to make a solid when lofting
             * @default false
             */
            this.makeSolid = false;
            /**
             * Will make a closed loft.
             * @default false
             */
            this.closed = false;
            /**
             * Will make a periodic loft.
             * @default false
             */
            this.periodic = false;
            /**
             * Indicates whether straight sections should be made out of the loft
             * @default false
             */
            this.straight = false;
            /**
             * This number only is used when closed non straight lofting is used
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrPeriodicSections = 10;
            /**
             * Tell algorithm to use smoothing
             * @default false
             */
            this.useSmoothing = false;
            /**
             * Maximum u degree
             * @default 3
             */
            this.maxUDegree = 3;
            /**
             * Tolerance
             * @default 1.0e-7
             * @minimum 0
             * @maximum Infinity
             * @step 0.000001
             */
            this.tolerance = 1.0e-7;
            /**
             * Approximation parametrization type
             * @default approxCentripetal
             */
            this.parType = ApproxParametrizationTypeEnum.approxCentripetal;
            this.shapes = shapes;
        }
    }
    OCCT.LoftAdvancedDto = LoftAdvancedDto;
    class OffsetDto {
        constructor(shape, distance, tolerance) {
            /**
             * Distance of offset
             * @default 0.2
             * @minimum -Infinity
             * @maximum Infinity
             * @step 0.1
             */
            this.distance = 0.2;
            /**
             * Offset tolerance
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @step 0.01
             */
            this.tolerance = 0.1;
            this.shape = shape;
            this.distance = distance;
            if (tolerance) {
                this.tolerance = tolerance;
            }
        }
    }
    OCCT.OffsetDto = OffsetDto;
    class OffsetAdvancedDto {
        constructor(shape, distance, tolerance) {
            /**
             * Distance of offset
             * @default 0.2
             * @minimum -Infinity
             * @maximum Infinity
             * @step 0.1
             */
            this.distance = 0.2;
            /**
             * Offset tolerance
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @step 0.01
             */
            this.tolerance = 0.1;
            /**
             * Join defines how to fill the holes that may appear between parallels to the two adjacent faces. It may take values GeomAbs_Arc or GeomAbs_Intersection:
             * if Join is equal to GeomAbs_Arc, then pipes are generated between two free edges of two adjacent parallels, and spheres are generated on "images" of vertices; it is the default value
             * @default arc
            */
            this.joinType = JoinTypeEnum.arc;
            /**
             * Removes internal edges
             * @default false
             */
            this.removeIntEdges = false;
            this.shape = shape;
            this.distance = distance;
            if (tolerance) {
                this.tolerance = tolerance;
            }
        }
    }
    OCCT.OffsetAdvancedDto = OffsetAdvancedDto;
    class RevolveDto {
        constructor(shape, degrees, direction, copy) {
            /**
             * Angle degrees
             * @default 360
             * @minimum 0
             * @maximum 360
             * @step 1
             */
            this.angle = 360;
            /**
             * Direction vector
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            /**
             * Copy original shape
             * @default false
             */
            this.copy = false;
            this.shape = shape;
            this.angle = degrees;
            this.direction = direction;
            if (this.copy) {
                this.copy = copy;
            }
        }
    }
    OCCT.RevolveDto = RevolveDto;
    class ShapeShapesDto {
        constructor(shape, shapes) {
            this.shape = shape;
            this.shapes = shapes;
        }
    }
    OCCT.ShapeShapesDto = ShapeShapesDto;
    class PipeWiresCylindricalDto {
        constructor(shapes) {
            /**
             * Radius of the cylindrical pipe
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.radius = 0.1;
            this.shapes = shapes;
        }
    }
    OCCT.PipeWiresCylindricalDto = PipeWiresCylindricalDto;
    class PipeWireCylindricalDto {
        constructor(shapes) {
            /**
             * Radius of the cylindrical pipe
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.radius = 0.1;
            this.shape = shapes;
        }
    }
    OCCT.PipeWireCylindricalDto = PipeWireCylindricalDto;
    class PipePolygonWireNGonDto {
        constructor(shapes) {
            /**
             * Radius of the cylindrical pipe
             * @default 0.1
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.radius = 0.1;
            /**
             * Nr of ngon corners to be used
             * @default 6
             * @minimum 3
             * @maximum Infinity
             * @step 1
             */
            this.nrCorners = 6;
            this.shape = shapes;
        }
    }
    OCCT.PipePolygonWireNGonDto = PipePolygonWireNGonDto;
    class ExtrudeDto {
        constructor(shape, direction) {
            /**
             * Direction vector for extrusion
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            this.shape = shape;
            this.direction = direction;
        }
    }
    OCCT.ExtrudeDto = ExtrudeDto;
    class ExtrudeShapesDto {
        constructor(shapes, direction) {
            /**
             * Direction vector for extrusion
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            this.shapes = shapes;
            this.direction = direction;
        }
    }
    OCCT.ExtrudeShapesDto = ExtrudeShapesDto;
    class SplitDto {
        constructor(shape, shapes) {
            this.shape = shape;
            this.shapes = shapes;
        }
    }
    OCCT.SplitDto = SplitDto;
    class UnionDto {
        constructor(shapes, keepEdges) {
            /**
             * Keeps edges
             * @default false
             */
            this.keepEdges = false;
            this.shapes = shapes;
            this.keepEdges = keepEdges;
        }
    }
    OCCT.UnionDto = UnionDto;
    class DifferenceDto {
        constructor(shape, shapes, keepEdges) {
            /**
             * Keeps edges unaffected
             * @default false
             */
            this.keepEdges = false;
            this.shape = shape;
            this.shapes = shapes;
            this.keepEdges = keepEdges;
        }
    }
    OCCT.DifferenceDto = DifferenceDto;
    class IntersectionDto {
        constructor(shapes, keepEdges) {
            /**
             * Keep the edges
             * @default false
             */
            this.keepEdges = false;
            this.shapes = shapes;
            this.keepEdges = keepEdges;
        }
    }
    OCCT.IntersectionDto = IntersectionDto;
    class ShapeDto {
        constructor(shape) {
            this.shape = shape;
        }
    }
    OCCT.ShapeDto = ShapeDto;
    class ShapesWithToleranceDto {
        constructor(shapes) {
            /**
             * Tolerance used for intersections
             * @default 1.0e-7
             * @minimum 0
             * @maximum Infinity
             * @step 0.000001
             */
            this.tolerance = 1.0e-7;
            this.shapes = shapes;
        }
    }
    OCCT.ShapesWithToleranceDto = ShapesWithToleranceDto;
    class ShapeWithToleranceDto {
        constructor(shape) {
            /**
             * Tolerance used for intersections
             * @default 1.0e-7
             * @minimum 0
             * @maximum Infinity
             * @step 0.000001
             */
            this.tolerance = 1.0e-7;
            this.shape = shape;
        }
    }
    OCCT.ShapeWithToleranceDto = ShapeWithToleranceDto;
    class ShapeIndexDto {
        constructor(shape, index) {
            /**
             * Index of the entity
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 1
             */
            this.index = 0;
            this.shape = shape;
            this.index = index;
        }
    }
    OCCT.ShapeIndexDto = ShapeIndexDto;
    class RotationExtrudeDto {
        constructor(shape, height, degrees) {
            /**
             * Height of rotation
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.height = 1;
            /**
             * Rotation in degrees
             * @default 360
             * @minimum 0
             * @maximum 360
             * @step 1
             */
            this.angle = 360;
            this.shape = shape;
            this.height = height;
            this.angle = degrees;
        }
    }
    OCCT.RotationExtrudeDto = RotationExtrudeDto;
    // Threading : Create Surfaces
    class ThickSolidByJoinDto {
        constructor(shape, shapes, offset) {
            /**
             * Offset to apply
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.offset = 1;
            /**
             * Tolerance defines the tolerance criterion for coincidence in generated shapes
             * @default 1.0e-3
             * @minimum 0
             * @maximum Infinity
             * @step 0.000001
             */
            this.tolerance = 1.e-3;
            /**
             * if Intersection is false (default value), the intersection is calculated with the parallels to the two adjacent shapes
             * @default false
             */
            this.intersection = false;
            /**
             * SelfInter tells the algorithm whether a computation to eliminate self-intersections needs to be applied to the resulting shape. However, as this functionality is not yet implemented, you should use the default value (false)
             * @default false
             */
            this.selfIntersection = false;
            /**
             * Join defines how to fill the holes that may appear between parallels to the two adjacent faces. It may take values GeomAbs_Arc or GeomAbs_Intersection:
             * if Join is equal to GeomAbs_Arc, then pipes are generated between two free edges of two adjacent parallels, and spheres are generated on "images" of vertices; it is the default value
             * @default arc
            */
            this.joinType = JoinTypeEnum.arc;
            /**
             * if Join is equal to GeomAbs_Intersection, then the parallels to the two adjacent faces are enlarged and intersected, so that there are no free edges on parallels to faces. RemoveIntEdges flag defines whether to remove the INTERNAL edges from the result or not. Warnings Since the algorithm of MakeThickSolid is based on MakeOffsetShape algorithm, the warnings are the same as for MakeOffsetShape.
             * @default false
             */
            this.removeIntEdges = false;
            this.shape = shape;
            this.shapes = shapes;
            this.offset = offset;
        }
    }
    OCCT.ThickSolidByJoinDto = ThickSolidByJoinDto;
    class TransformDto {
        constructor(shape, translation, rotationAxis, rotationDegrees, scaleFactor) {
            /**
             * Translation to apply
             * @default [0,0,0]
             */
            this.translation = [0, 0, 0];
            /**
             * Rotation to apply
             * @default [0,1,0]
             */
            this.rotationAxis = [0, 1, 0];
            /**
             * Rotation degrees
             * @default 0
             * @minimum 0
             * @maximum 360
             * @step 1
             */
            this.rotationAngle = 0;
            /**
             * Scale factor to apply
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.scaleFactor = 1;
            this.shape = shape;
            this.translation = translation;
            this.rotationAxis = rotationAxis;
            this.rotationAngle = rotationDegrees;
            this.scaleFactor = scaleFactor;
        }
    }
    OCCT.TransformDto = TransformDto;
    class TransformShapesDto {
        constructor(shapes, translation, rotationAxes, rotationDegrees, scaleFactors) {
            /**
             * Translation to apply
             * @default [[0,0,0]]
             */
            this.translations = [[0, 0, 0]];
            /**
             * Rotation to apply
             * @default [[0,1,0]]
             */
            this.rotationAxes = [[0, 1, 0]];
            /**
             * Rotation degrees
             * @default [0]
             */
            this.rotationAngles = [0];
            /**
             * Scale factor to apply
             * @default [1]
             */
            this.scaleFactors = [1];
            this.shapes = shapes;
            this.translations = translation;
            this.rotationAxes = rotationAxes;
            this.rotationAngles = rotationDegrees;
            this.scaleFactors = scaleFactors;
        }
    }
    OCCT.TransformShapesDto = TransformShapesDto;
    class TranslateDto {
        constructor(shape, translation) {
            /**
             * Translation vector
             * @default [0, 0, 0]
             */
            this.translation = [0, 0, 0];
            this.shape = shape;
            this.translation = translation;
        }
    }
    OCCT.TranslateDto = TranslateDto;
    class TranslateShapesDto {
        constructor(shapes, translations) {
            /**
             * Translation vector
             * @default [[0, 0, 0]]
             */
            this.translations = [[0, 0, 0]];
            this.shapes = shapes;
            this.translations = translations;
        }
    }
    OCCT.TranslateShapesDto = TranslateShapesDto;
    class AlignDto {
        constructor(shape, fromOrigin, fromDirection, toOrigin, toDirection) {
            /**
             * from origin
             * @default [0, 0, 0]
             */
            this.fromOrigin = [0, 0, 0];
            /**
             * From direction
             * @default [0, 0, 1]
             */
            this.fromDirection = [0, 0, 1];
            /**
             * To origin
             * @default [0, 1, 0]
             */
            this.toOrigin = [0, 1, 0];
            /**
             * To direction
             * @default [0, 1, 0]
             */
            this.toDirection = [0, 1, 0];
            this.shape = shape;
            this.fromOrigin = fromOrigin;
            this.fromDirection = fromDirection;
            this.toOrigin = toOrigin;
            this.toDirection = toDirection;
        }
    }
    OCCT.AlignDto = AlignDto;
    class AlignShapesDto {
        constructor(shapes, fromOrigins, fromDirections, toOrigins, toDirections) {
            /**
             * from origin
             * @default [[0, 0, 0]]
             */
            this.fromOrigins = [[0, 0, 0]];
            /**
             * From direction
             * @default [[0, 0, 1]]
             */
            this.fromDirections = [[0, 0, 1]];
            /**
             * To origin
             * @default [[0, 1, 0]]
             */
            this.toOrigins = [[0, 1, 0]];
            /**
             * To direction
             * @default [[0, 1, 0]]
             */
            this.toDirections = [[0, 1, 0]];
            this.shapes = shapes;
            this.fromOrigins = fromOrigins;
            this.fromDirections = fromDirections;
            this.toOrigins = toOrigins;
            this.toDirections = toDirections;
        }
    }
    OCCT.AlignShapesDto = AlignShapesDto;
    class MirrorDto {
        constructor(shape, origin, direction) {
            /**
             * Axis origin point
             * @default [0, 0, 0]
             */
            this.origin = [0, 0, 0];
            /**
             * Axis direction vector
             * @default [0, 0, 1]
             */
            this.direction = [0, 0, 1];
            this.shape = shape;
            this.direction = direction;
            this.origin = origin;
        }
    }
    OCCT.MirrorDto = MirrorDto;
    class MirrorShapesDto {
        constructor(shapes, origins, directions) {
            /**
             * Axis origin point
             * @default [[0, 0, 0]]
             */
            this.origins = [[0, 0, 0]];
            /**
             * Axis direction vector
             * @default [[0, 0, 1]]
             */
            this.directions = [[0, 0, 1]];
            this.shapes = shapes;
            this.directions = directions;
            this.origins = origins;
        }
    }
    OCCT.MirrorShapesDto = MirrorShapesDto;
    class MirrorAlongNormalDto {
        constructor(shape, origin, normal) {
            /**
             * Axis origin point
             * @default [0, 0, 0]
             */
            this.origin = [0, 0, 0];
            /**
             * First normal axis direction vector
             * @default [0, 0, 1]
             */
            this.normal = [0, 0, 1];
            this.shape = shape;
            this.normal = normal;
            this.origin = origin;
        }
    }
    OCCT.MirrorAlongNormalDto = MirrorAlongNormalDto;
    class MirrorAlongNormalShapesDto {
        constructor(shapes, origins, normals) {
            /**
             * Axis origin point
             * @default [[0, 0, 0]]
             */
            this.origins = [[0, 0, 0]];
            /**
             * First normal axis direction vector
             * @default [[0, 0, 1]]
             */
            this.normals = [[0, 0, 1]];
            this.shapes = shapes;
            this.normals = normals;
            this.origins = origins;
        }
    }
    OCCT.MirrorAlongNormalShapesDto = MirrorAlongNormalShapesDto;
    class AlignAndTranslateDto {
        constructor(shape, direction, center) {
            /**
             * Direction on which to align
             * @default [0, 0, 1]
             */
            this.direction = [0, 1, 0];
            /**
             * Position to translate
             */
            this.center = [0, 0, 0];
            this.shape = shape;
            this.direction = direction;
            this.center = center;
        }
    }
    OCCT.AlignAndTranslateDto = AlignAndTranslateDto;
    class AlignAndTranslateShapesDto {
        constructor(shapes, directions, centers) {
            /**
             * Directions on which to align
             * @default [0, 0, 1]
             */
            this.directions = [[0, 1, 0]];
            /**
             * Positions to translate
             */
            this.centers = [[0, 0, 0]];
            this.shapes = shapes;
            this.directions = directions;
            this.centers = centers;
        }
    }
    OCCT.AlignAndTranslateShapesDto = AlignAndTranslateShapesDto;
    class RotateDto {
        constructor(shape, axis, degrees) {
            /**
             * Axis on which to rotate
             * @default [0, 0, 1]
             */
            this.axis = [0, 0, 1];
            /**
             * Rotation degrees
             * @default 0
             * @minimum 0
             * @maximum 360
             * @step 1
             */
            this.angle = 0;
            this.shape = shape;
            this.axis = axis;
            this.angle = degrees;
        }
    }
    OCCT.RotateDto = RotateDto;
    class RotateAroundCenterDto {
        constructor(shape, angle, center, axis) {
            /**
             * Angle of rotation to apply
             * @default 0
             */
            this.angle = 0;
            /**
             * Center of the rotation
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Axis around which to rotate
             * @default [0, 0, 1]
             */
            this.axis = [0, 0, 1];
            this.shape = shape;
            this.angle = angle;
            this.center = center;
            this.axis = axis;
        }
    }
    OCCT.RotateAroundCenterDto = RotateAroundCenterDto;
    class RotateShapesDto {
        constructor(shapes, axes, angles) {
            /**
             * Rotation degrees
             * @default [0]
             */
            this.angles = [0];
            this.shapes = shapes;
            this.axes = axes;
            this.angles = angles;
        }
    }
    OCCT.RotateShapesDto = RotateShapesDto;
    class RotateAroundCenterShapesDto {
        constructor(shapes, angles, centers, axes) {
            /**
             * Angles of rotation to apply
             * @default [0]
             */
            this.angles = [0];
            /**
             * Centers around which to rotate
             * @default [[0, 0, 0]]
             */
            this.centers = [[0, 0, 0]];
            /**
             * Axes around which to rotate
             * @default [[0, 0, 1]]
             */
            this.axes = [[0, 0, 1]];
            this.shapes = shapes;
            this.angles = angles;
            this.centers = centers;
            this.axes = axes;
        }
    }
    OCCT.RotateAroundCenterShapesDto = RotateAroundCenterShapesDto;
    class ScaleDto {
        constructor(shape, scale) {
            /**
             * Scale factor to apply
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.factor = 1;
            this.shape = shape;
            this.factor = scale;
        }
    }
    OCCT.ScaleDto = ScaleDto;
    class ScaleShapesDto {
        constructor(shapes, factors) {
            /**
             * Scale factor to apply
             * @default [1]
             */
            this.factors = [1];
            this.shapes = shapes;
            this.factors = factors;
        }
    }
    OCCT.ScaleShapesDto = ScaleShapesDto;
    class Scale3DDto {
        constructor(shape, scale, center) {
            /**
             * Scale factor to apply
             * @default [1, 1, 1]
             */
            this.scale = [1, 1, 1];
            /**
             * Scale from the center
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            this.shape = shape;
            this.scale = scale;
            this.center = center;
        }
    }
    OCCT.Scale3DDto = Scale3DDto;
    class Scale3DShapesDto {
        constructor(shapes, scales, centers) {
            /**
             * Scale factor to apply
             * @default [[1, 1, 1]]
             */
            this.scales = [[1, 1, 1]];
            /**
             * Scale from the center
             * @default [[0, 0, 0]]
             */
            this.centers = [[0, 0, 0]];
            this.shapes = shapes;
            this.scales = scales;
            this.centers = centers;
        }
    }
    OCCT.Scale3DShapesDto = Scale3DShapesDto;
    class ShapeToMeshDto {
        constructor(shape, precision, adjustYtoZ) {
            /**
             * Precision of the mesh
             * @default 0.01
             * @minimum 0
             * @maximum Infinity
             * @step 0.001
             */
            this.precision = 0.01;
            /**
             * Adjust Y (up) coordinate system to Z (up) coordinate system
             * @default false
             */
            this.adjustYtoZ = false;
            this.shape = shape;
            if (precision) {
                this.precision = precision;
            }
            if (adjustYtoZ) {
                this.adjustYtoZ = adjustYtoZ;
            }
        }
    }
    OCCT.ShapeToMeshDto = ShapeToMeshDto;
    class SaveStepDto {
        constructor(shape, filename, adjustYtoZ) {
            /**
             * File name
             * @default shape.step
             */
            this.filename = "shape.step";
            /**
             * Adjust Y (up) coordinate system to Z (up) coordinate system
             * @default false
             */
            this.adjustYtoZ = false;
            this.shape = shape;
            this.filename = filename;
            this.adjustYtoZ = adjustYtoZ;
        }
    }
    OCCT.SaveStepDto = SaveStepDto;
    class SaveStlDto {
        constructor(shape, filename, precision, adjustYtoZ) {
            /**
             * File name
             * @default shape.stl
             */
            this.filename = "shape.stl";
            /**
             * Precision of the mesh - lower means higher res
             * @default 0.01
             */
            this.precision = 0.01;
            /**
             * Adjust Y (up) coordinate system to Z (up) coordinate system
             * @default false
             */
            this.adjustYtoZ = false;
            this.shape = shape;
            this.filename = filename;
            this.precision = precision;
            this.adjustYtoZ = adjustYtoZ;
        }
    }
    OCCT.SaveStlDto = SaveStlDto;
    class ImportStepIgesDto {
        constructor(assetFile, adjustZtoY) {
            /**
             * Adjusts models that use Z coordinate as up to Y up system.
             * @default true
             */
            this.adjustZtoY = true;
            this.assetFile = assetFile;
            this.adjustZtoY = adjustZtoY;
        }
    }
    OCCT.ImportStepIgesDto = ImportStepIgesDto;
    class LoadStepOrIgesDto {
        constructor(filetext, filename, adjustZtoY) {
            /**
             * File name
             * @default shape.igs
             */
            this.filename = "shape.igs";
            /**
             * Adjusts models that use Z coordinate as up to Y up system.
             * @default true
             */
            this.adjustZtoY = true;
            this.filetext = filetext;
            this.filename = filename;
            this.adjustZtoY = adjustZtoY;
        }
    }
    OCCT.LoadStepOrIgesDto = LoadStepOrIgesDto;
    class CompoundShapesDto {
        constructor(shapes) {
            this.shapes = shapes;
        }
    }
    OCCT.CompoundShapesDto = CompoundShapesDto;
    class ThisckSolidSimpleDto {
        constructor(shape, offset) {
            /**
             * Offset distance
             * @default 1
             * @minimum -Infinity
             * @maximum Infinity
             * @step 0.1
             */
            this.offset = 1;
            this.shape = shape;
            this.offset = offset;
        }
    }
    OCCT.ThisckSolidSimpleDto = ThisckSolidSimpleDto;
    class FaceFromWireDto {
        constructor(shape, planar) {
            /**
             * Should plane be planar
             * @default false
             */
            this.planar = false;
            this.shape = shape;
            this.planar = planar;
        }
    }
    OCCT.FaceFromWireDto = FaceFromWireDto;
    class FacesFromWiresDto {
        constructor(shapes, planar) {
            /**
             * Should plane be planar
             * @default false
             */
            this.planar = false;
            this.shapes = shapes;
            this.planar = planar;
        }
    }
    OCCT.FacesFromWiresDto = FacesFromWiresDto;
    class SewDto {
        constructor(shapes, tolerance) {
            /**
             * Tolerance of sewing
             * @default 1.0e-7
             * @minimum 0
             * @maximum Infinity
             * @step 0.00001
             */
            this.tolerance = 1.0e-7;
            this.shapes = shapes;
            this.tolerance = tolerance;
        }
    }
    OCCT.SewDto = SewDto;
    class FaceIsoCurveAtParamDto {
        constructor(shape, param) {
            /**
             * Direction to find the isocurve
             * @default u
             */
            this.dir = "u";
            this.shape = shape;
            this.param = param;
        }
    }
    OCCT.FaceIsoCurveAtParamDto = FaceIsoCurveAtParamDto;
    class DivideFaceToUVPointsDto {
        constructor(shape) {
            /**
             * Number of points on U direction
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrOfPointsU = 10;
            /**
             * Number of points on V direction
             * @default 10
             * @minimum 1
             * @maximum Infinity
             * @step 1
             */
            this.nrOfPointsV = 10;
            /**
             * Flatten the output
             * @default false
             */
            this.flat = false;
            this.shape = shape;
        }
    }
    OCCT.DivideFaceToUVPointsDto = DivideFaceToUVPointsDto;
    class Geom2dEllipseDto {
        constructor() {
            /**
             * Center of the ellipse
             * @default [0,0]
             */
            this.center = [0, 0];
            /**
             * Direction of the vector
             * @default [1,0]
             */
            this.direction = [1, 0];
            /**
             * Minor radius of an ellipse
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radiusMinor = 1;
            /**
             * Major radius of an ellipse
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radiusMajor = 2;
            /**
             * If true will sense the direction
             * @default false
             */
            this.sense = false;
        }
    }
    OCCT.Geom2dEllipseDto = Geom2dEllipseDto;
    class Geom2dCircleDto {
        constructor() {
            /**
             * Center of the circle
             * @default [0,0]
             */
            this.center = [0, 0];
            /**
             * Direction of the vector
             * @default [1,0]
             */
            this.direction = [1, 0];
            /**
             * Radius of the circle
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius = 1;
            /**
             * If true will sense the direction
             * @default false
             */
            this.sense = false;
        }
    }
    OCCT.Geom2dCircleDto = Geom2dCircleDto;
    class StarDto {
        constructor() {
            /**
             * Center of the circle
             * @default [0,0,0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            /**
             * Direction of the vector
             * @default 7
             * @minimum 3
             * @maximum Infinity
             * @step 1
             */
            this.numRays = 7;
            /**
             * Construct half of the star
             * @default false
             */
            this.half = false;
        }
    }
    OCCT.StarDto = StarDto;
    class ParallelogramDto {
        constructor() {
            /**
             * Center of the circle
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            /**
             * Indicates whether to draw the parallelogram around the center point or start from corner.
             * @default true
             */
            this.aroundCenter = true;
            /**
             * Width of bounding rectangle
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.width = 2;
            /**
             * Height of bounding rectangle
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.height = 1;
            /**
             * Sharp angle of the parallelogram
             * @default 15
             * @minimum -Infinity
             * @maximum Infinity
             * @step 1
             */
            this.angle = 15;
        }
    }
    OCCT.ParallelogramDto = ParallelogramDto;
    class Heart2DDto {
        constructor() {
            /**
             * Center of the circle
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            /**
             * Rotation of the hear
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 15
             */
            this.rotation = 0;
            /**
             * Size of the bounding box within which the heart gets drawn
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.sizeApprox = 2;
        }
    }
    OCCT.Heart2DDto = Heart2DDto;
    class NGonWireDto {
        constructor() {
            /**
             * Center of the circle
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            /**
             * How many corners to create.
             * @default 6
             * @minimum 3
             * @maximum Infinity
             * @step 1
             */
            this.nrCorners = 6;
            /**
             * Radius of nGon
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius = 1;
        }
    }
    OCCT.NGonWireDto = NGonWireDto;
    class EllipseDto {
        constructor() {
            /**
             * Center of the ellipse
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Direction of the vector
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
            /**
             * Minor radius of an ellipse
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radiusMinor = 1;
            /**
             * Major radius of an ellipse
             * @default 2
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radiusMajor = 2;
        }
    }
    OCCT.EllipseDto = EllipseDto;
    class GeomCylindricalSurfaceDto {
        constructor() {
            /**
             * Radius of the cylindrical surface
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.radius = 1;
            /**
             * Center of the cylindrical surface
             * @default [0, 0, 0]
             */
            this.center = [0, 0, 0];
            /**
             * Axis of direction for cylindrical surface
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
        }
    }
    OCCT.GeomCylindricalSurfaceDto = GeomCylindricalSurfaceDto;
    class Geom2dTrimmedCurveDto {
        constructor() {
            /**
             * First param on the curve for trimming. U1 can be greater or lower than U2. The returned curve is oriented from U1 to U2.
             * @default 0
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.u1 = 0;
            /**
             * Second parameter on the curve for trimming
             * @default 1
             * @minimum 0
             * @maximum Infinity
             * @step 0.1
             */
            this.u2 = 1;
            /**
             *  If the basis curve C is periodic there is an ambiguity because two parts are available.
             *  In this case by default the trimmed curve has the same orientation as the basis curve (Sense = True).
             * If Sense = False then the orientation of the trimmed curve is opposite to the orientation of the basis curve C.
             * @default true
             */
            this.sense = true;
            /**
             * If the curve is closed but not periodic it is not possible to keep the part of the curve including the
             * junction point (except if the junction point is at the beginning or at the end of the trimmed curve)
             * because you could lose the fundamental characteristics of the basis curve which are used for example
             * to compute the derivatives of the trimmed curve. So for a closed curve the rules are the same as for a open curve.
             * @default true
             */
            this.theAdjustPeriodic = true;
        }
    }
    OCCT.Geom2dTrimmedCurveDto = Geom2dTrimmedCurveDto;
    class Geom2dSegmentDto {
        constructor() {
            /**
             * Start 2d point for segment
             * @default [0, 0]
             */
            this.start = [0, 0];
            /**
             * End 2d point for segment
             * @default [1, 0]
             */
            this.end = [1, 0];
        }
    }
    OCCT.Geom2dSegmentDto = Geom2dSegmentDto;
    class SliceDto {
        constructor() {
            /**
             * Step at which to divide the shape
             * @default 2
             * @minimum 1
             * @maximum Infinity
             * @step 0.1
             */
            this.step = 2;
            /**
             * Direction vector
             * @default [0, 1, 0]
             */
            this.direction = [0, 1, 0];
        }
    }
    OCCT.SliceDto = SliceDto;
})(OCCT || (OCCT = {}));
