import { Base } from "./inputs";
export declare namespace OCCT {
    type GeomCurvePointer = {
        hash: number;
        type: string;
    };
    type Geom2dCurvePointer = {
        hash: number;
        type: string;
    };
    type GeomSurfacePointer = {
        hash: number;
        type: string;
    };
    type TopoDSVertexPointer = {
        hash: number;
        type: string;
    };
    type TopoDSEdgePointer = {
        hash: number;
        type: string;
    };
    type TopoDSWirePointer = {
        hash: number;
        type: string;
    };
    type TopoDSFacePointer = {
        hash: number;
        type: string;
    };
    type TopoDSShellPointer = {
        hash: number;
        type: string;
    };
    type TopoDSSolidPointer = {
        hash: number;
        type: string;
    };
    type TopoDSCompSolidPointer = {
        hash: number;
        type: string;
    };
    type TopoDSCompoundPointer = {
        hash: number;
        type: string;
    };
    type TopoDSShapePointer = TopoDSVertexPointer | TopoDSEdgePointer | TopoDSWirePointer | TopoDSFacePointer | TopoDSShellPointer | TopoDSSolidPointer | TopoDSCompoundPointer;
    enum joinTypeEnum {
        arc = "arc",
        intersection = "intersection",
        tangent = "tangent"
    }
    enum bRepOffsetModeEnum {
        skin = "skin",
        pipe = "pipe",
        rectoVerso = "rectoVerso"
    }
    enum approxParametrizationTypeEnum {
        approxChordLength = "approxChordLength",
        approxCentripetal = "approxCentripetal",
        approxIsoParametric = "approxIsoParametric"
    }
    enum directionEnum {
        outside = "outside",
        inside = "inside",
        middle = "middle"
    }
    enum fileTypeEnum {
        iges = "iges",
        step = "step"
    }
    enum topAbsOrientationEnum {
        forward = "forward",
        reversed = "reversed",
        internal = "internal",
        external = "external"
    }
    enum topAbsStateEnum {
        in = "in",
        out = "out",
        on = "on",
        unknown = "unknown"
    }
    enum shapeTypeEnum {
        unknown = "unknown",
        vertex = "vertex",
        edge = "edge",
        wire = "wire",
        face = "face",
        shell = "shell",
        solid = "solid",
        compSolid = "compSolid",
        compound = "compound",
        shape = "shape"
    }
    enum gccEntPositionEnum {
        unqualified = "unqualified",
        enclosing = "enclosing",
        enclosed = "enclosed",
        outside = "outside",
        noqualifier = "noqualifier"
    }
    enum positionResultEnum {
        keepSide1 = "keepSide1",
        keepSide2 = "keepSide2",
        all = "all"
    }
    enum circleInclusionEnum {
        none = "none",
        keepSide1 = "keepSide1",
        keepSide2 = "keepSide2"
    }
    enum twoCircleInclusionEnum {
        none = "none",
        outside = "outside",
        inside = "inside",
        outsideInside = "outsideInside",
        insideOutside = "insideOutside"
    }
    enum fourSidesStrictEnum {
        outside = "outside",
        inside = "inside",
        outsideInside = "outsideInside",
        insideOutside = "insideOutside"
    }
    enum twoSidesStrictEnum {
        outside = "outside",
        inside = "inside"
    }
    enum combinationCirclesForFaceEnum {
        allWithAll = "allWithAll",
        inOrder = "inOrder",
        inOrderClosed = "inOrderClosed"
    }
    enum typeSpecificityEnum {
        curve = 0,
        edge = 1,
        wire = 2,
        face = 3
    }
    enum pointProjectionTypeEnum {
        all = "all",
        closest = "closest",
        furthest = "furthest",
        closestAndFurthest = "closestAndFurthest"
    }
    enum geomFillTrihedronEnum {
        isCorrectedFrenet = "isCorrectedFrenet",
        isFixed = "isFixed",
        isFrenet = "isFrenet",
        isConstantNormal = "isConstantNormal",
        isDarboux = "isDarboux",
        isGuideAC = "isGuideAC",
        isGuidePlan = "isGuidePlan",
        isGuideACWithContact = "isGuideACWithContact",
        isGuidePlanWithContact = "isGuidePlanWithContact",
        isDiscreteTrihedron = "isDiscreteTrihedron"
    }
    class DecomposedMeshDto {
        constructor(faceList?: DecomposedFaceDto[], edgeList?: DecomposedEdgeDto[]);
        /**
         * Face list for decomposed faces
         */
        faceList: DecomposedFaceDto[];
        /**
         * Edge list for decomposed edges
         */
        edgeList: DecomposedEdgeDto[];
        /**
         * The points list in a shape that includes vertex shapes
         */
        pointsList: Base.Point3[];
    }
    class DecomposedFaceDto {
        face_index: number;
        normal_coord: number[];
        number_of_triangles: number;
        tri_indexes: number[];
        vertex_coord: number[];
        vertex_coord_vec: Base.Vector3[];
        center_point: Base.Point3;
        center_normal: Base.Vector3;
        uvs: number[];
    }
    class DecomposedEdgeDto {
        edge_index: number;
        middle_point: Base.Point3;
        vertex_coord: Base.Vector3[];
    }
    class ShapesDto<T> {
        constructor(shapes?: T[]);
        /**
         * The OCCT shapes
         * @default undefined
         */
        shapes: T[];
    }
    class PointDto {
        constructor(point?: Base.Point3);
        /**
         * The point
         * @default [0, 0, 0]
         */
        point: Base.Point3;
    }
    class XYZDto {
        constructor(x?: number, y?: number, z?: number);
        /**
         * X coord
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        x: number;
        /**
         * Y coord
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        y: number;
        /**
         * Z coord
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        z: number;
    }
    class PointsDto {
        constructor(points?: Base.Point3[]);
        /**
         * The point
         * @default undefined
         */
        points: Base.Point3[];
    }
    class ConstraintTanLinesFromPtToCircleDto<T> {
        constructor(circle?: T, point?: Base.Point3, tolerance?: number, positionResult?: positionResultEnum, circleRemainder?: circleInclusionEnum);
        /**
         * The circle for tangent points
         * @default undefined
         */
        circle: T;
        /**
         * The point from which to find the lines
         * @default undefined
         */
        point: Base.Point3;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
        /**
         * Filters resulting lines by position
         * @default all
         */
        positionResult: positionResultEnum;
        /**
         * Splits provided circle on tangent points and adds it to the solutions
         * This only works when number of solutions contains 2 lines, when solution involves more than 4 lines, this option will be ignored.
         * @default none
         */
        circleRemainder: circleInclusionEnum;
    }
    class ConstraintTanLinesFromTwoPtsToCircleDto<T> {
        constructor(circle?: T, point1?: Base.Point3, point2?: Base.Point3, tolerance?: number, positionResult?: positionResultEnum, circleRemainder?: circleInclusionEnum);
        /**
         * The circle for tangent points
         * @default undefined
         */
        circle: T;
        /**
         * The point from which to find the lines
         * @default undefined
         */
        point1: Base.Point3;
        /**
         * The point from which to find the lines
         * @default undefined
         */
        point2: Base.Point3;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
        /**
         * Filters resulting lines by position
         * @default all
         */
        positionResult: positionResultEnum;
        /**
         * Splits provided circle on tangent points and adds it to the solutions
         * This only works when number of solutions contains 2 lines, when solution involves more than 4 lines, this option will be ignored.
         * @default none
         */
        circleRemainder: circleInclusionEnum;
    }
    class ConstraintTanLinesOnTwoCirclesDto<T> {
        constructor(circle1?: T, circle2?: T, tolerance?: number, positionResult?: positionResultEnum, circleRemainders?: twoCircleInclusionEnum);
        /**
         * The first circle for tangential lines
         * @default undefined
         */
        circle1: T;
        /**
         * The second circle for tangential lines
         * @default undefined
         */
        circle2: T;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
        /**
         * Filters resulting lines by position relative to circles
         * @default all
         */
        positionResult: positionResultEnum;
        /**
         * Splits provided circles on tangent points and returns those as part of the solutions
         * This only works when number of solutions is limited to 2 lines, when solution involves more than 4 lines, this option will be ignored.
         * @default none
         */
        circleRemainders: twoCircleInclusionEnum;
    }
    class ConstraintTanCirclesOnTwoCirclesDto<T> {
        constructor(circle1?: T, circle2?: T, tolerance?: number, radius?: number);
        /**
         * The first circle for tangential lines
         * @default undefined
         */
        circle1: T;
        /**
         * The second circle for tangential lines
         * @default undefined
         */
        circle2: T;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
        /**
         * Radius of the circles being constructed
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
    }
    class ConstraintTanCirclesOnCircleAndPntDto<T> {
        constructor(circle?: T, point?: Base.Point3, tolerance?: number, radius?: number);
        /**
         * The first circle for tangential lines
         * @default undefined
         */
        circle: T;
        /**
         * The second circle for tangential lines
         * @default undefined
         */
        point: Base.Point3;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
        /**
         * Radius of the circles being constructed
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
    }
    class CurveAndSurfaceDto<T, U> {
        constructor(curve?: T, surface?: U);
        /**
         * Curve
         * @default undefined
         */
        curve: T;
        /**
         * Surface
         * @default undefined
         */
        surface: U;
    }
    class FilletTwoEdgesInPlaneDto<T> {
        constructor(edge1?: T, edge2?: T, planeOrigin?: Base.Point3, planeDirection?: Base.Vector3, radius?: number, solution?: number);
        /**
         * First OCCT edge to fillet
         * @default undefined
         */
        edge1: T;
        /**
         * Second OCCT edge to fillet
         * @default undefined
         */
        edge2: T;
        /**
         * Plane origin that is also used to find the closest solution if two solutions exist.
         * @default [0, 0, 0]
         */
        planeOrigin: Base.Point3;
        /**
         * Plane direction for fillet
         * @default [0, 1, 0]
         */
        planeDirection: Base.Vector3;
        /**
         * Radius of the fillet
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * 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
         */
        solution?: number;
    }
    class ClosestPointsOnShapeFromPointsDto<T> {
        constructor(shape?: T, points?: Base.Point3[]);
        /**
         * The OCCT shape
         * @default undefined
         */
        shape: T;
        /**
         * The list of points
         * @default undefined
         */
        points: Base.Point3[];
    }
    class BoundingBoxDto {
        constructor(bbox?: BoundingBoxPropsDto);
        /**
         * Bounding box
         * @default undefined
         */
        bbox?: BoundingBoxPropsDto;
    }
    class BoundingBoxPropsDto {
        constructor(min?: Base.Point3, max?: Base.Point3, center?: Base.Point3, size?: Base.Vector3);
        /**
         * Minimum point of the bounding box
         * @default [0, 0, 0]
         */
        min: Base.Point3;
        /**
         * Maximum point of the bounding box
         * @default [0, 0, 0]
         */
        max: Base.Point3;
        /**
         * Center point of the bounding box
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Size of the bounding box
         * @default [0, 0, 0]
         */
        size: Base.Vector3;
    }
    class BoundingSpherePropsDto {
        constructor(center?: Base.Point3, radius?: number);
        /**
         * Center point of the bounding box
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Radius of the bounding sphere
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
    }
    class SplitWireOnPointsDto<T> {
        constructor(shape?: T, points?: Base.Point3[]);
        /**
         * The OCCT wire shape
         * @default undefined
         */
        shape: T;
        /**
         * The list of points
         * @default undefined
         */
        points: Base.Point3[];
    }
    class ClosestPointsOnShapesFromPointsDto<T> {
        constructor(shapes?: T[], points?: Base.Point3[]);
        /**
         * The OCCT shapes
         * @default undefined
         */
        shapes: T[];
        /**
         * The list of points
         * @default undefined
         */
        points: Base.Point3[];
    }
    class ClosestPointsBetweenTwoShapesDto<T> {
        constructor(shape1?: T, shape2?: T);
        /**
         * First OCCT shape
         * @default undefined
         */
        shape1: T;
        /**
        * Second OCCT shape
        * @default undefined
        */
        shape2: T;
    }
    class FaceFromSurfaceAndWireDto<T, U> {
        constructor(surface?: T, wire?: U, inside?: boolean);
        /**
         * Surface from which to create a face
         * @default undefined
         */
        surface: T;
        /**
         * Wire that represents a boundary on the surface to delimit the face
         * @default undefined
         */
        wire: U;
        /**
         * Indicates wether face should be created inside or outside the wire
         * @default true
         */
        inside: boolean;
    }
    class WireOnFaceDto<T, U> {
        constructor(wire?: T, face?: U);
        /**
         * Wire to place on face
         * @default undefined
         */
        wire: T;
        /**
         * Face on which the wire will be placed
         * @default undefined
         */
        face: U;
    }
    class DrawShapeDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shape?: T, faceOpacity?: number, edgeOpacity?: number, edgeColour?: Base.Color, faceMaterial?: Base.Material, faceColour?: Base.Color, edgeWidth?: number, drawEdges?: boolean, drawFaces?: boolean, drawVertices?: boolean, vertexColour?: Base.Color, vertexSize?: number, precision?: number, drawEdgeIndexes?: boolean, edgeIndexHeight?: number, edgeIndexColour?: Base.Color, drawFaceIndexes?: boolean, faceIndexHeight?: number, faceIndexColour?: Base.Color);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape?: T;
        /**
         * Face opacity value between 0 and 1
         * @default 1
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        faceOpacity: number;
        /**
         * Edge opacity value between 0 and 1
         * @default 1
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        edgeOpacity: number;
        /**
         * Hex colour string for the edges
         * @default #ffffff
         */
        edgeColour: Base.Color;
        /**
         * Face material
         * @default undefined
         * @optional true
         */
        faceMaterial?: Base.Material;
        /**
         * Hex colour string for face colour
         * @default #ff0000
         */
        faceColour: Base.Color;
        /**
         * Edge width
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        edgeWidth: number;
        /**
         * You can turn off drawing of edges via this property
         * @default true
         */
        drawEdges: boolean;
        /**
         * You can turn off drawing of faces via this property
         * @default true
         */
        drawFaces: boolean;
        /**
         * You can turn off drawing of vertexes via this property
         * @default false
         */
        drawVertices: boolean;
        /**
         * Color of the vertices that will be drawn
         * @default #ff00ff
         */
        vertexColour: string;
        /**
         * The size of a vertices that will be drawn
         * @default 0.03
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        vertexSize: number;
        /**
         * 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
         */
        precision: number;
        /**
         * Draw index of edges in space
         * @default false
         */
        drawEdgeIndexes: boolean;
        /**
         * Indicates the edge index height if they are drawn
         * @default 0.06
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        edgeIndexHeight: number;
        /**
         * Edge index colour if the edges are drawn
         * @default #ff00ff
         */
        edgeIndexColour: Base.Color;
        /**
         * Draw indexes of faces in space
         * @default false
         */
        drawFaceIndexes: boolean;
        /**
         * Indicates the edge index height if they are drawn
         * @default 0.06
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        faceIndexHeight: number;
        /**
         * Edge index colour if the edges are drawn
         * @default #0000ff
         */
        faceIndexColour: Base.Color;
    }
    class DrawShapesDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shapes?: T[], faceOpacity?: number, edgeOpacity?: number, edgeColour?: Base.Color, faceMaterial?: Base.Material, faceColour?: Base.Color, edgeWidth?: number, drawEdges?: boolean, drawFaces?: boolean, drawVertices?: boolean, vertexColour?: Base.Color, vertexSize?: number, precision?: number, drawEdgeIndexes?: boolean, edgeIndexHeight?: number, edgeIndexColour?: Base.Color, drawFaceIndexes?: boolean, faceIndexHeight?: number, faceIndexColour?: Base.Color);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shapes: T[];
        /**
         * Face opacity value between 0 and 1
         * @default 1
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        faceOpacity: number;
        /**
         * Edge opacity value between 0 and 1
         * @default 1
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        edgeOpacity: number;
        /**
         * Hex colour string for the edges
         * @default #ffffff
         */
        edgeColour: Base.Color;
        /**
         * Face material
         * @default undefined
         * @optional true
         */
        faceMaterial?: Base.Material;
        /**
         * Hex colour string for face colour
         * @default #ff0000
         */
        faceColour: Base.Color;
        /**
         * Edge width
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        edgeWidth: number;
        /**
         * You can turn off drawing of edges via this property
         * @default true
         */
        drawEdges: boolean;
        /**
         * You can turn off drawing of faces via this property
         * @default true
         */
        drawFaces: boolean;
        /**
         * You can turn off drawing of vertexes via this property
         * @default false
         */
        drawVertices: boolean;
        /**
         * Color of the vertices that will be drawn
         * @default #ff00ff
         */
        vertexColour: string;
        /**
         * The size of a vertices that will be drawn
         * @default 0.03
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        vertexSize: number;
        /**
         * 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
         */
        precision: number;
        /**
         * Draw index of edges in space
         * @default false
         */
        drawEdgeIndexes: boolean;
        /**
         * Indicates the edge index height if they are drawn
         * @default 0.06
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        edgeIndexHeight: number;
        /**
         * Edge index colour if the edges are drawn
         * @default #ff00ff
         */
        edgeIndexColour: Base.Color;
        /**
         * Draw indexes of faces in space
         * @default false
         */
        drawFaceIndexes: boolean;
        /**
         * Indicates the edge index height if they are drawn
         * @default 0.06
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        faceIndexHeight: number;
        /**
         * Edge index colour if the edges are drawn
         * @default #0000ff
         */
        faceIndexColour: Base.Color;
    }
    class FaceSubdivisionDto<T> {
        /**
          * Provide options without default values
          */
        constructor(shape?: T, nrDivisionsU?: number, nrDivisionsV?: number, shiftHalfStepU?: boolean, removeStartEdgeU?: boolean, removeEndEdgeU?: boolean, shiftHalfStepV?: boolean, removeStartEdgeV?: boolean, removeEndEdgeV?: boolean);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape: T;
        /**
         * Number of points that will be added on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrDivisionsU: number;
        /**
         * Number  of points that will be added on V direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrDivisionsV: number;
        /**
         * Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
         * @default false
         */
        shiftHalfStepU: boolean;
        /**
         * Removes start edge points on U
         * @default false
         */
        removeStartEdgeU: boolean;
        /**
         * Removes end edge points on U
         * @default false
         */
        removeEndEdgeU: boolean;
        /**
         * Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
         * @default false
         */
        shiftHalfStepV: boolean;
        /**
         * Removes start edge points on V
         * @default false
         */
        removeStartEdgeV: boolean;
        /**
         * Removes end edge points on V
         * @default false
         */
        removeEndEdgeV: boolean;
    }
    class FaceSubdivisionToWiresDto<T> {
        /**
          * Provide options without default values
          */
        constructor(shape?: T, nrDivisions?: number, isU?: boolean, shiftHalfStep?: boolean, removeStart?: boolean, removeEnd?: boolean);
        /**
         * Openascade Face
         * @default undefined
         */
        shape: T;
        /**
         * Number of points that will be added on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrDivisions: number;
        /**
        * Linear subdivision direction true - U, false - V
        * @default true
        */
        isU: boolean;
        /**
         * Sometimes you want to shift your wires half way the step distance, especially on periodic surfaces
         * @default false
         */
        shiftHalfStep: boolean;
        /**
         * Removes start wire
         * @default false
         */
        removeStart: boolean;
        /**
         * Removes end wire
         * @default false
         */
        removeEnd: boolean;
    }
    class FaceSubdivideToRectangleWiresDto<T> {
        /**
          * Provide options without default values
          */
        constructor(shape?: T, nrRectanglesU?: number, nrRectanglesV?: number, scalePatternU?: number[], scalePatternV?: number[], filletPattern?: number[], inclusionPattern?: boolean[], offsetFromBorderU?: number, offsetFromBorderV?: number);
        /**
         * Openascade Face
         * @default undefined
         */
        shape: T;
        /**
         * Number of rectangles on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrRectanglesU: number;
        /**
         * Number of rectangles on V direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrRectanglesV: number;
        /**
         * Rectangle scale pattern on u direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
         * @default undefined
         * @optional true
         */
        scalePatternU: number[];
        /**
         * Rectangle scale pattern on v direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
         * @default undefined
         * @optional true
         */
        scalePatternV: number[];
        /**
         * Rectangle fillet scale pattern - numbers between 0 and 1, if 0 is used, no fillet is applied,
         * if 1 is used, the fillet will be exactly half of the length of the shorter side of the rectangle
         * @default undefined
         * @optional true
         */
        filletPattern: number[];
        /**
         * Rectangle inclusion pattern - true means that the rectangle will be included,
         * false means that the rectangle will be removed from the face
         * @default undefined
         * @optional true
         */
        inclusionPattern: boolean[];
        /**
         * If offset on U is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of U param 1 will be offset from the face border
         * That is often required to create a pattern that is not too close to the face border
         * It should not be bigger then half of the total width of the face as that will create problems
         * @default 0
         * @minimum 0
         * @maximum 0.5
         * @step 0.01
         */
        offsetFromBorderU: number;
        /**
         * If offset on V is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of V param 1 will be offset from the face border
         * That is often required to create a pattern that is not too close to the face border
         * It should not be bigger then half of the total width of the face as that will create problems
         * @default 0
         * @minimum 0
         * @maximum 0.5
         * @step 0.01
         */
        offsetFromBorderV: number;
    }
    class FaceSubdivideToRectangleHolesDto<T> {
        /**
          * Provide options without default values
          */
        constructor(shape?: T, nrRectanglesU?: number, nrRectanglesV?: number, scalePatternU?: number[], scalePatternV?: number[], filletPattern?: number[], inclusionPattern?: boolean[], holesToFaces?: boolean, offsetFromBorderU?: number, offsetFromBorderV?: number);
        /**
         * Openascade Face
         * @default undefined
         */
        shape: T;
        /**
         * Number of rectangles on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrRectanglesU: number;
        /**
         * Number of rectangles on V direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrRectanglesV: number;
        /**
         * Rectangle scale pattern on u direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
         * @default undefined
         * @optional true
         */
        scalePatternU: number[];
        /**
         * Rectangle scale pattern on v direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
         * @default undefined
         * @optional true
         */
        scalePatternV: number[];
        /**
         * Rectangle fillet scale pattern - numbers between 0 and 1, if 0 is used, no fillet is applied,
         * if 1 is used, the fillet will be exactly half of the length of the shorter side of the rectangle
         * @default undefined
         * @optional true
         */
        filletPattern: number[];
        /**
         * Rectangle inclusion pattern - true means that the rectangle will be included,
         * false means that the rectangle will be removed from the face
         * @default undefined
         * @optional true
         */
        inclusionPattern: boolean[];
        /**
         * If true, we will also output the faces for all the rectangles. The first face in the result will be the original face with holes punched, while the rest will be the rectangles
         * @default false
         */
        holesToFaces: boolean;
        /**
         * If offset on U is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of U param 1 will be offset from the face border
         * That is often required to create a pattern that is not too close to the face border
         * It should not be bigger then half of the total width of the face as that will create problems
         * @default 0
         * @minimum 0
         * @maximum 0.5
         * @step 0.01
         */
        offsetFromBorderU: number;
        /**
         * If offset on V is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of V param 1 will be offset from the face border
         * That is often required to create a pattern that is not too close to the face border
         * It should not be bigger then half of the total width of the face as that will create problems
         * @default 0
         * @minimum 0
         * @maximum 0.5
         * @step 0.01
         */
        offsetFromBorderV: number;
    }
    class FaceSubdivisionControlledDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shape?: T, nrDivisionsU?: number, nrDivisionsV?: number, shiftHalfStepNthU?: number, shiftHalfStepUOffsetN?: number, removeStartEdgeNthU?: number, removeStartEdgeUOffsetN?: number, removeEndEdgeNthU?: number, removeEndEdgeUOffsetN?: number, shiftHalfStepNthV?: number, shiftHalfStepVOffsetN?: number, removeStartEdgeNthV?: number, removeStartEdgeVOffsetN?: number, removeEndEdgeNthV?: number, removeEndEdgeVOffsetN?: number);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape: T;
        /**
         * Number of subdivisions on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrDivisionsU: number;
        /**
         * Number of subdivisions on V direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrDivisionsV: number;
        /**
         * Shift half step every nth U row
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        shiftHalfStepNthU: number;
        /**
         * Offset for shift half step every nth U row
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        shiftHalfStepUOffsetN: number;
        /**
         * Removes start edge points on U
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeStartEdgeNthU: number;
        /**
         * Offset for remove start edge points on U
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeStartEdgeUOffsetN: number;
        /**
         * Removes end edge points on U
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeEndEdgeNthU: number;
        /**
         * Offset for remove end edge points on U
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeEndEdgeUOffsetN: number;
        /**
         * Shift half step every nth V row
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        shiftHalfStepNthV: number;
        /**
         * Offset for shift half step every nth V row
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        shiftHalfStepVOffsetN: number;
        /**
         * Removes start edge points on V
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeStartEdgeNthV: number;
        /**
         * Offset for remove start edge points on V
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeStartEdgeVOffsetN: number;
        /**
         * Removes end edge points on V
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeEndEdgeNthV: number;
        /**
         * Offset for remove end edge points on V
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        removeEndEdgeVOffsetN: number;
    }
    class FaceLinearSubdivisionDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shape?: T, isU?: boolean, param?: number, nrPoints?: number, shiftHalfStep?: boolean, removeStartPoint?: boolean, removeEndPoint?: boolean);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape: T;
        /**
         * Linear subdivision direction true - U, false - V
         * @default true
         */
        isU: boolean;
        /**
         * Param on direction 0 - 1
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        param: number;
        /**
         * Number of subdivisions on opposite direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrPoints: number;
        /**
         * Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
         * @default false
         */
        shiftHalfStep: boolean;
        /**
         * Removes first point
         * @default false
         */
        removeStartPoint: boolean;
        /**
         * Removes last point
         * @default false
         */
        removeEndPoint: boolean;
    }
    class WireAlongParamDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shape?: T, isU?: boolean, param?: number);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape: T;
        /**
         * Linear subdivision direction true - U, false - V
         * @default true
         */
        isU: boolean;
        /**
         * Param on direction 0 - 1
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        param: number;
    }
    class WiresAlongParamsDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shape?: T, isU?: boolean, params?: number[]);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape: T;
        /**
         * Linear subdivision direction true - U, false - V
         * @default true
         */
        isU: boolean;
        /**
         * Params on direction 0 - 1
         * @default undefined
         */
        params: number[];
    }
    class DataOnUVDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shape?: T, paramU?: number, paramV?: number);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape: T;
        /**
         * Param on U direction 0 to 1
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        paramU: number;
        /**
         * Param on V direction 0 to 1
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        paramV: number;
    }
    class DataOnUVsDto<T> {
        /**
         * Provide options without default values
         */
        constructor(shape?: T, paramsUV?: [number, number][]);
        /**
         * Brep OpenCascade geometry
         * @default undefined
         */
        shape: T;
        /**
         * Params uv
         * @default [[0.5, 0.5]]
         */
        paramsUV: [number, number][];
    }
    class PolygonDto {
        constructor(points?: Base.Point3[]);
        /**
         * Points points
         * @default undefined
         */
        points: Base.Point3[];
    }
    class PolygonsDto {
        constructor(polygons?: PolygonDto[], returnCompound?: boolean);
        /**
         * Polygons
         * @default undefined
         */
        polygons: PolygonDto[];
        /**
         * Indicates whether the shapes should be returned as a compound
         */
        returnCompound: boolean;
    }
    class PolylineDto {
        constructor(points?: Base.Point3[]);
        /**
         * Points points
         * @default undefined
         */
        points: Base.Point3[];
    }
    class PolylinesDto {
        constructor(polylines?: PolylineDto[], returnCompound?: boolean);
        /**
         * Polylines
         * @default undefined
         */
        polylines: PolylineDto[];
        /**
         * Indicates whether the shapes should be returned as a compound
         */
        returnCompound: boolean;
    }
    class SquareDto {
        constructor(size?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * size of square
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        size: number;
        /**
         * Center of the square
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the square
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class RectangleDto {
        constructor(width?: number, length?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * width of the rectangle
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        width: number;
        /**
         * Height of the rectangle
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        length: number;
        /**
         * Center of the rectangle
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the rectangle
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class LPolygonDto {
        constructor(widthFirst?: number, lengthFirst?: number, widthSecond?: number, lengthSecond?: number, align?: directionEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Width of the first side of L polygon
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        widthFirst: number;
        /**
         * Length of the first side of L polygon
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        lengthFirst: number;
        /**
         * Width of the second side of L polygon
         * @default 0.5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        widthSecond: number;
        /**
         * Length of the second side of L polygon
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        lengthSecond: number;
        /**
         * Indicates if the L polygon should be aligned inside/outside or middle
         * @default outside
         */
        align: directionEnum;
        /**
         * Rotation of the L polygon
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 15
         */
        rotation: number;
        /**
         * Center of the L polygon
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the  L polygon
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class BoxDto {
        constructor(width?: number, length?: number, height?: number, center?: Base.Point3, originOnCenter?: boolean);
        /**
         * Width of the box
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width: number;
        /**
         * Length of the box
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        length: number;
        /**
         * Height of the box
         * @default 3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Center of the box
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Force origin to be on the center of the cube
         * @default true
         */
        originOnCenter?: boolean;
    }
    class CubeDto {
        constructor(size?: number, center?: Base.Point3, originOnCenter?: boolean);
        /**
         * Size of the cube
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        size: number;
        /**
         * Center of the box
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Force origin to be on the center of the cube
         * @default true
         */
        originOnCenter?: boolean;
    }
    class BoxFromCornerDto {
        constructor(width?: number, length?: number, height?: number, corner?: Base.Point3);
        /**
         * Width of the box
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width: number;
        /**
         * Length of the box
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        length: number;
        /**
         * Height of the box
         * @default 3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Corner of the box
         * @default [0, 0, 0]
         */
        corner: Base.Point3;
    }
    class SphereDto {
        constructor(radius?: number, center?: Base.Point3);
        /**
         * Radius of the sphere
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Center of the sphere
         * @default [0, 0, 0]
         */
        center: Base.Point3;
    }
    class ConeDto {
        constructor(radius1?: number, radius2?: number, height?: number, angle?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * First radius of the cone
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius1: number;
        /**
         * Second radius of the cone
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius2: number;
        /**
         * Height of the cone
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Angle of the cone
         * @default 360
         * @minimum 0
         * @maximum 360
         * @step 1
         */
        angle: number;
        /**
         * Center of the cone
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the cone
         * @default [0, 1, 0]
         */
        direction: Base.Point3;
    }
    class LineDto {
        constructor(start?: Base.Point3, end?: Base.Point3);
        /**
         * Start of the line
         * @default [0, 0, 0]
         */
        start: Base.Point3;
        /**
         * End of the line
         * @default [0, 1, 0]
         */
        end: Base.Point3;
    }
    class LinesDto {
        constructor(lines?: LineDto[], returnCompound?: boolean);
        /**
         * Lines
         * @default undefined
         */
        lines: LineDto[];
        /**
         * Indicates whether the shapes should be returned as a compound
         */
        returnCompound: boolean;
    }
    class ArcEdgeTwoPointsTangentDto {
        constructor(start?: Base.Point3, tangentVec?: Base.Vector3, end?: Base.Point3);
        /**
         * Start of the arc
         * @default [0, 0, 0]
         */
        start: Base.Point3;
        /**
        * Tangent vector on first point of the edge
        * @default [0, 1, 0]
        */
        tangentVec: Base.Vector3;
        /**
         * End of the arc
         * @default [0, 0, 1]
         */
        end: Base.Point3;
    }
    class ArcEdgeCircleTwoPointsDto<T> {
        constructor(circle?: T, start?: Base.Point3, end?: Base.Point3, sense?: boolean);
        /**
         * Circular edge
         * @default undefined
         */
        circle: T;
        /**
         * Start of the arc on the circle
         * @default [0, 0, 0]
         */
        start: Base.Point3;
        /**
         * End of the arc on the circle
         * @default [0, 0, 1]
         */
        end: Base.Point3;
        /**
         * If true will sense the direction
         * @default true
         */
        sense: boolean;
    }
    class ArcEdgeCircleTwoAnglesDto<T> {
        constructor(circle?: T, alphaAngle1?: number, alphaAngle2?: number, sense?: boolean);
        /**
         * Circular edge
         * @default undefined
         */
        circle: T;
        /**
         * First angle
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 1
         */
        alphaAngle1: number;
        /**
         * End angle
         * @default 90
         * @minimum -Infinity
         * @maximum Infinity
         * @step 1
         */
        alphaAngle2: number;
        /**
         * If true will sense the direction
         * @default true
         */
        sense: boolean;
    }
    class ArcEdgeCirclePointAngleDto<T> {
        constructor(circle?: T, alphaAngle?: number, alphaAngle2?: number, sense?: boolean);
        /**
         * Circular edge
         * @default undefined
         */
        circle: T;
        /**
         * Point on the circle from where to start the arc
         * @default undefined
         */
        point: Base.Point3;
        /**
         * Angle from point
         * @default 90
         * @minimum -Infinity
         * @maximum Infinity
         * @step 1
         */
        alphaAngle: number;
        /**
         * If true will sense the direction
         * @default true
         */
        sense: boolean;
    }
    class ArcEdgeThreePointsDto {
        constructor(start?: Base.Point3, middle?: Base.Point3, end?: Base.Point3);
        /**
         * Start of the arc
         * @default [0, 0, 0]
         */
        start: Base.Point3;
        /**
        * Middle of the arc
        * @default [0, 1, 0]
        */
        middle: Base.Point3;
        /**
         * End of the arc
         * @default [0, 0, 1]
         */
        end: Base.Point3;
    }
    class CylinderDto {
        constructor(radius?: number, height?: number, center?: Base.Point3, direction?: Base.Vector3, angle?: number, originOnCenter?: boolean);
        /**
         * Radius of the cylinder
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Height of the cylinder
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Center of the cylinder
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction for the cylinder
         * @default [0, 1, 0]
         */
        direction?: Base.Vector3;
        /**
         * Angle of the cylinder pie
         * @default 360
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        angle?: number;
        /**
         * Force origin to be on the center of cylinder
         * @default false
         */
        originOnCenter?: boolean;
    }
    class CylindersOnLinesDto {
        constructor(radius?: number, lines?: Base.Line3[]);
        /**
         * Radius of the cylinder
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Lines between which to span cylinders
         * @default undefined
         */
        lines: Base.Line3[];
    }
    class FilletDto<T> {
        constructor(shape?: T, radius?: number, radiusList?: number[], indexes?: number[]);
        /**
         * Shape to apply the fillets
         * @default undefined
         */
        shape: T;
        /**
         * Radius of the fillets
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         * @optional true
         */
        radius?: number;
        /**
         * Radius list
         * @default undefined
         * @optional true
         */
        radiusList?: number[];
        /**
         * List of edge indexes to which apply the fillet, if left empty all edges will be rounded
         * @default undefined
         * @optional true
         */
        indexes?: number[];
    }
    class FilletShapesDto<T> {
        constructor(shapes?: T[], radius?: number, radiusList?: number[], indexes?: number[]);
        /**
         * Shapes to apply the fillets
         * @default undefined
         */
        shapes: T[];
        /**
         * Radius of the fillets
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         * @optional true
         */
        radius?: number;
        /**
         * Radius list
         * @default undefined
         * @optional true
         */
        radiusList?: number[];
        /**
         * List of edge indexes to which apply the fillet, if left empty all edges will be rounded
         * @default undefined
         * @optional true
         */
        indexes?: number[];
    }
    class FilletEdgesListDto<T, U> {
        constructor(shape?: T, edges?: U[], radiusList?: number[]);
        /**
         * Shape to apply the fillet
         * @default undefined
         */
        shape: T;
        /**
         * Edges to use for the fillet
         * @default undefined
         */
        edges: U[];
        /**
         * Radius list for the fillets. The length of this array must match the length of the edges array. Each index corresponds to fillet on the edge at the same index.
         * @default undefined
         */
        radiusList: number[];
    }
    class FilletEdgesListOneRadiusDto<T, U> {
        constructor(shape?: T, edges?: U[], radius?: number);
        /**
         * Shape to apply the fillet
         * @default undefined
         */
        shape: T;
        /**
         * Edges to use for the fillet
         * @default undefined
         */
        edges: U[];
        /**
         * Radius of the fillets
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         * @optional true
         */
        radius: number;
    }
    class FilletEdgeVariableRadiusDto<T, U> {
        constructor(shape?: T, edge?: U, radiusList?: number[], paramsU?: number[]);
        /**
         * Shape to apply the fillet
         * @default undefined
         */
        shape: T;
        /**
         * Edge to use for the fillet
         * @default undefined
         */
        edge: U;
        /**
         * Radius list for the fillets that has to match the paramsU list
         * @default undefined
         */
        radiusList: number[];
        /**
         * List of parameters on the edge to which apply the fillet. Each param must be between 0 and 1.
         * @default undefined
         */
        paramsU: number[];
    }
    class FilletEdgesVariableRadiusDto<T, U> {
        constructor(shape?: T, edges?: U[], radiusLists?: number[][], paramsULists?: number[][]);
        /**
         * Shape to apply the fillet
         * @default undefined
         */
        shape: T;
        /**
         * Edges to use for the fillet
         * @default undefined
         */
        edges: U[];
        /**
         * Lists of radius lists for the fillets. Top level array length needs to match the nr of edges used and each second level array needs to match paramsU length array at the same index.
         * @default undefined
         */
        radiusLists: number[][];
        /**
         * Lists of parameter lists on the edges to which apply the fillet. Each param must be between 0 and 1. Top level array length needs to match the nr of edges used and each second level array needs to match radius length array at the same index.
         * @default undefined
         */
        paramsULists: number[][];
    }
    class FilletEdgesSameVariableRadiusDto<T, U> {
        constructor(shape?: T, edges?: U[], radiusList?: number[], paramsU?: number[]);
        /**
         * Shape to apply the fillet
         * @default undefined
         */
        shape: T;
        /**
         * Edges to use for the fillet
         * @default undefined
         */
        edges: U[];
        /**
         * Radius list for the fillets that has to match the paramsU list
         * @default undefined
         */
        radiusList: number[];
        /**
         * List of parameters on the edges to which apply the fillet. Each param must be between 0 and 1.
         * @default undefined
         */
        paramsU: number[];
    }
    class Fillet3DWiresDto<T> {
        constructor(shapes?: T[], radius?: number, direction?: Base.Vector3, radiusList?: number[], indexes?: number[]);
        /**
         * Shapes to apply the fillets on
         * @default undefined
         */
        shapes: T[];
        /**
         * Radius of the fillets
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         * @optional true
         */
        radius?: number;
        /**
         * Radius list
         * @default undefined
         * @optional true
         */
        radiusList?: number[];
        /**
         * List of edge indexes to which apply the fillet, if left empty all edges will be rounded
         * @default undefined
         * @optional true
         */
        indexes?: number[];
        /**
         * Orientation direction for the fillet
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class Fillet3DWireDto<T> {
        constructor(shape?: T, radius?: number, direction?: Base.Vector3, radiusList?: number[], indexes?: number[]);
        /**
         * Shape to apply the fillets
         * @default undefined
         */
        shape: T;
        /**
         * Radius of the fillets
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         * @optional true
         */
        radius?: number;
        /**
         * Radius list
         * @default undefined
         * @optional true
         */
        radiusList?: number[];
        /**
         * List of edge indexes to which apply the fillet, if left empty all edges will be rounded
         * @default undefined
         * @optional true
         */
        indexes?: number[];
        /**
         * Orientation direction for the fillet
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class ChamferDto<T> {
        constructor(shape?: T, distance?: number, distanceList?: number[], indexes?: number[]);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Distance for the chamfer
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @optional true
         * @step 0.1
         */
        distance?: number;
        /**
         * Distance for the chamfer
         * @default undefined
         * @optional true
         */
        distanceList?: number[];
        /**
         * List of edge indexes to which apply the chamfer, if left empty all edges will be chamfered
         * @default undefined
         * @optional true
         */
        indexes?: number[];
    }
    class ChamferEdgesListDto<T, U> {
        constructor(shape?: T, edges?: U[], distanceList?: number[]);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Edges to apply the chamfer to
         * @default undefined
         */
        edges: U[];
        /**
         * Distance for the chamfer
         * @default undefined
         */
        distanceList: number[];
    }
    class ChamferEdgeDistAngleDto<T, U, F> {
        constructor(shape?: T, edge?: U, face?: F, distance?: number, angle?: number);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Edge to apply the chamfer to
         * @default undefined
         */
        edge: U;
        /**
         * Face from which to apply the angle
         * @default undefined
         */
        face: F;
        /**
         * Distance for the chamfer
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        distance: number;
        /**
         * Angle for the chamfer
         * @default 45
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        angle: number;
    }
    class ChamferEdgeTwoDistancesDto<T, U, F> {
        constructor(shape?: T, edge?: U, face?: F, distance1?: number, distance2?: number);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Edge to apply the chamfer to
         * @default undefined
         */
        edge: U;
        /**
         * Face from which to apply the first distance
         * @default undefined
         */
        face: F;
        /**
         * First distance from the face for the chamfer
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        distance1: number;
        /**
         * Second distance for the chamfer
         * @default 0.2
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        distance2: number;
    }
    class ChamferEdgesTwoDistancesListsDto<T, U, F> {
        constructor(shape?: T, edges?: U[], faces?: F[], distances1?: number[], distances2?: number[]);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Edges to apply the chamfers to
         * @default undefined
         */
        edges: U[];
        /**
         * Faces from which to apply the angle of the chamfers
         * @default undefined
         */
        faces: F[];
        /**
         * Distance 1 list for the chamfers
         * @default undefined
         */
        distances1: number[];
        /**
         * Distance 2 list for the chamfers
         * @default undefined
         */
        distances2: number[];
    }
    class ChamferEdgesTwoDistancesDto<T, U, F> {
        constructor(shape?: T, edges?: U[], faces?: F[], distance1?: number, distance2?: number);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Edges to apply the chamfers to
         * @default undefined
         */
        edges: U[];
        /**
         * Faces from which to apply the angle of the chamfers
         * @default undefined
         */
        faces: F[];
        /**
         * First distance from the face for the chamfer
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        distance1: number;
        /**
         * Second distance for the chamfer
         * @default 0.2
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        distance2: number;
    }
    class ChamferEdgesDistsAnglesDto<T, U, F> {
        constructor(shape?: T, edges?: U[], faces?: F[], distances?: number[], angles?: number[]);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Edges to apply the chamfers to
         * @default undefined
         */
        edges: U[];
        /**
         * Faces from which to apply the angle of the chamfers
         * @default undefined
         */
        faces: F[];
        /**
         * Distance list for the chamfers
         * @default undefined
         */
        distances: number[];
        /**
         * Angles for the chamfers
         * @default undefined
         */
        angles: number[];
    }
    class ChamferEdgesDistAngleDto<T, U, F> {
        constructor(shape?: T, edges?: U[], faces?: F[], distance?: number, angle?: number);
        /**
         * Shape to apply the chamfer
         * @default undefined
         */
        shape: T;
        /**
         * Edges to apply the chamfers to
         * @default undefined
         */
        edges: U[];
        /**
         * Faces from which to apply the angle of the chamfers
         * @default undefined
         */
        faces: F[];
        /**
         * Distance from the face
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        distance: number;
        /**
         * Angle for the chamfers
         * @default 45
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        angle: number;
    }
    class BSplineDto {
        constructor(points?: Base.Point3[], closed?: boolean);
        /**
         * Points through which the BSpline will be created
         * @default undefined
         */
        points: Base.Point3[];
        /**
         * Indicates wether BSpline will be cloed
         * @default false
         */
        closed: boolean;
    }
    class BSplinesDto {
        constructor(bSplines?: BSplineDto[], returnCompound?: boolean);
        /**
         * BSpline definitions
         * @default undefined
         */
        bSplines: BSplineDto[];
        /**
         * Indicates whether the shapes should be returned as a compound
         */
        returnCompound: boolean;
    }
    class WireFromTwoCirclesTanDto<T> {
        constructor(circle1?: T, circle2?: T, keepLines?: twoSidesStrictEnum, circleRemainders?: fourSidesStrictEnum, tolerance?: number);
        /**
         * The first circle to be encloed with tangential lines
         * @default undefined
         */
        circle1: T;
        /**
         * The second circle to be encloed with tangential lines
         * @default undefined
         */
        circle2: T;
        /**
         * Choose which side to keep for the wire. Outside gives non-intersecting solution.
         * @default outside
         */
        keepLines: twoSidesStrictEnum;
        /**
         * Choose which side to keep for the wire. Outside gives non-intersecting solution.
         * @default outside
         */
        circleRemainders: fourSidesStrictEnum;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
    }
    class FaceFromMultipleCircleTanWiresDto<T> {
        constructor(circles?: T[], combination?: combinationCirclesForFaceEnum, unify?: boolean, tolerance?: number);
        /**
         * The circles that will all be joined into a single face through tangential lines
         * @default undefined
         */
        circles: T[];
        /**
         * Indicates how circles should be joined together. Users can choose to join all circles with each other. Alternatively it is possible to respect the order of circles and only join consecutive circles. It is also possible to respect order and close the shape with first circle in the list.
         * @default allWithAll
         */
        combination: combinationCirclesForFaceEnum;
        /**
         * Choose whether you want faces to be unifided into a single face or not. Sometimes if you want to get faster result you can set this to false, but in this case faces will be returned as compound.
         * @default true
         */
        unify: boolean;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
    }
    class FaceFromMultipleCircleTanWireCollectionsDto<T> {
        constructor(listsOfCircles?: T[][], combination?: combinationCirclesForFaceEnum, unify?: boolean, tolerance?: number);
        /**
         * The two dimensional circle array that can host multiple circle collections.
         * @default undefined
         */
        listsOfCircles: T[][];
        /**
         * Indicates how circles should be joined together. Users can choose to join all circles with each other. Alternatively it is possible to respect the order of circles and only join consecutive circles. It is also possible to respect order and close the shape with first circle in the list.
         * @default allWithAll
         */
        combination: combinationCirclesForFaceEnum;
        /**
         * Choose whether you want faces to be unifided into a single face or not. Sometimes if you want to get faster result you can set this to false, but in this case faces will be returned as compound.
         * @default true
         */
        unify: boolean;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
    }
    class ZigZagBetweenTwoWiresDto<T> {
        constructor(wire1?: T, wire2?: T, nrZigZags?: number, inverse?: boolean, divideByEqualDistance?: boolean, zigZagsPerEdge?: boolean);
        /**
         * The first wire for zig zag
         * @default undefined
         */
        wire1: T;
        /**
         * The second wire for zig zag
         * @default undefined
         */
        wire2: T;
        /**
         * How many zig zags to create between the two wires on each edge. The number of edges should match. Edges will be joined by zigzags in order. One zig zag means two edges forming a corner.
         * @default 20
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrZigZags: number;
        /**
         * Inverse the the zig zag to go from wire2 to wire1
         * @default false
         */
        inverse: boolean;
        /**
         * If true, the zig zags will be spaced equally on each edge. By default we follow parametric subdivision of the edges, which is not always equal to distance based subdivisions.
         * @default false
         */
        divideByEqualDistance: boolean;
        /**
         * By default the number of zig zags is applied to each edge. If this is set to false, the number of zig zags will be applied to the whole wire. This could then skip some corners where edges meet.
         * @default true
         */
        zigZagsPerEdge: boolean;
    }
    class InterpolationDto {
        constructor(points?: Base.Point3[], periodic?: boolean, tolerance?: number);
        /**
         * Points through which the BSpline will be created
         * @default undefined
         */
        points: Base.Point3[];
        /**
         * Indicates wether BSpline will be periodic
         * @default false
         */
        periodic: boolean;
        /**
         * tolerance
         * @default 1e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
    }
    class InterpolateWiresDto {
        constructor(interpolations?: InterpolationDto[], returnCompound?: boolean);
        /**
         * Interpolation definitions
         * @default undefined
         */
        interpolations: InterpolationDto[];
        /**
         * Indicates whether the shapes should be returned as a compound
         */
        returnCompound: boolean;
    }
    class BezierDto {
        constructor(points?: Base.Point3[], closed?: boolean);
        /**
         * Points through which the Bezier curve will be created
         * @default undefined
         */
        points: Base.Point3[];
        /**
         * Indicates wether Bezier will be cloed
         * @default false
         */
        closed: boolean;
    }
    class BezierWeightsDto {
        constructor(points?: Base.Point3[], weights?: number[], closed?: boolean);
        /**
         * Points through which the Bezier curve will be created
         * @default undefined
         */
        points: Base.Point3[];
        /**
        * Weights for beziers that will be used, values should be between 0 and 1
        * @default undefined
        */
        weights: number[];
        /**
         * Indicates wether Bezier will be cloed
         * @default false
         */
        closed: boolean;
    }
    class BezierWiresDto {
        constructor(bezierWires?: BezierDto[], returnCompound?: boolean);
        /**
         * Bezier wires
         * @default undefined
         */
        bezierWires: BezierDto[];
        /**
         * Indicates whether the shapes should be returned as a compound
         */
        returnCompound: boolean;
    }
    class DivideDto<T> {
        constructor(shape: T, nrOfDivisions?: number, removeStartPoint?: boolean, removeEndPoint?: boolean);
        /**
         * Shape representing a wire
         * @default undefined
         */
        shape: T;
        /**
         * The number of divisions that will be performed on the curve
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrOfDivisions: number;
        /**
         * Indicates if algorithm should remove start point
         * @default false
         */
        removeStartPoint: boolean;
        /**
         * Indicates if algorithm should remove end point
         * @default false
         */
        removeEndPoint: boolean;
    }
    class ProjectWireDto<T, U> {
        constructor(wire?: T, shape?: U, direction?: Base.Vector3);
        /**
         * Wire to project
         * @default undefined
         */
        wire: T;
        /**
         * Shape to use for projection
         * @default undefined
         */
        shape: U;
        /**
         * Direction vector for projection
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class ProjectPointsOnShapeDto<T> {
        constructor(points?: Base.Point3[], shape?: T, direction?: Base.Vector3, projectionType?: pointProjectionTypeEnum);
        /**
         * Points to project
         * @default undefined
         */
        points: Base.Point3[];
        /**
         * Shape to use for projection
         * @default undefined
         */
        shape: T;
        /**
         * Direction vector for projection - this must take the length into account as well, because algorithm looks for intresections with the shape in this direction. It will not find solutions outside the given length of this vector.
         * @default [0, 10, 0]
         */
        direction: Base.Vector3;
        /**
         * Allows user to choose what solutions are being returned by this operation.
         * @default all
         */
        projectionType: pointProjectionTypeEnum;
    }
    class WiresToPointsDto<T> {
        constructor(shape?: T, angularDeflection?: number, curvatureDeflection?: number, minimumOfPoints?: number, uTolerance?: number, minimumLength?: number);
        /**
         * Shape to use for parsing edges
         * @default undefined
         */
        shape: T;
        /**
         * The angular deflection
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        angularDeflection: number;
        /**
         * The curvature deflection
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.001
         */
        curvatureDeflection: number;
        /**
         * Minimum of points
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        minimumOfPoints: number;
        /**
         * U tolerance
         * @default 1.0e-9
         * @minimum 0
         * @maximum Infinity
         * @step 1.0e-9
         */
        uTolerance: number;
        /**
         * Minimum length
         * @default 1.0e-7
         * @minimum 0
         * @maximum Infinity
         * @step 1.0e-7
         */
        minimumLength: number;
    }
    class EdgesToPointsDto<T> {
        constructor(shape?: T, angularDeflection?: number, curvatureDeflection?: number, minimumOfPoints?: number, uTolerance?: number, minimumLength?: number);
        /**
         * Shape to use for parsing edges
         * @default undefined
         */
        shape: T;
        /**
         * The angular deflection
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        angularDeflection: number;
        /**
         * The curvature deflection
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.001
         */
        curvatureDeflection: number;
        /**
         * Minimum of points
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        minimumOfPoints: number;
        /**
         * U tolerance
         * @default 1.0e-9
         * @minimum 0
         * @maximum Infinity
         * @step 1.0e-9
         */
        uTolerance: number;
        /**
         * Minimum length
         * @default 1.0e-7
         * @minimum 0
         * @maximum Infinity
         * @step 1.0e-7
         */
        minimumLength: number;
    }
    class ProjectWiresDto<T, U> {
        constructor(wires?: T[], shape?: U, direction?: Base.Vector3);
        /**
         * Wire to project
         * @default undefined
         */
        wires: T[];
        /**
         * Shape to use for projection
         * @default undefined
         */
        shape: U;
        /**
         * Direction vector for projection
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class DivideShapesDto<T> {
        constructor(shapes: T[], nrOfDivisions?: number, removeStartPoint?: boolean, removeEndPoint?: boolean);
        /**
         * Shapes
         * @default undefined
         */
        shapes: T[];
        /**
         * The number of divisions that will be performed on the curve
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrOfDivisions: number;
        /**
         * Indicates if algorithm should remove start point
         * @default false
         */
        removeStartPoint: boolean;
        /**
         * Indicates if algorithm should remove end point
         * @default false
         */
        removeEndPoint: boolean;
    }
    class DataOnGeometryAtParamDto<T> {
        constructor(shape: T, param?: number);
        /**
         * Shape representing a geometry
         * @default undefined
         */
        shape: T;
        /**
         * 0 - 1 value
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        param: number;
    }
    class DataOnGeometryesAtParamDto<T> {
        constructor(shapes: T[], param?: number);
        /**
         * Shapes representing a geometry
         * @default undefined
         */
        shapes: T[];
        /**
         * 0 - 1 value
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        param: number;
    }
    class PointInFaceDto<T> {
        constructor(face: T, edge: T, tEdgeParam?: number, distance2DParam?: number);
        /**
         * OCCT face to be used for calculation
         * @default undefined
         */
        face: T;
        /**
         * OCCT edge to be used for calculation
         * @default undefined
         */
        edge: T;
        /**
         * 0 - 1 value
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        tEdgeParam: number;
        /**
         * The point will be distanced on <distance2DParam> from the 2d curve.
         * @default 0.5
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        distance2DParam: number;
    }
    class PointsOnWireAtEqualLengthDto<T> {
        constructor(shape: T, length?: number, tryNext?: boolean, includeFirst?: boolean, includeLast?: boolean);
        /**
         * Shape representing a wire
         * @default undefined
         */
        shape: T;
        /**
         * length at which to evaluate the point
         * @default 0.5
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        length: number;
        /**
         * Try next point if the point is not found
         * @default false
         */
        tryNext: boolean;
        /**
         * Include first point
         * @default false
         */
        includeFirst: boolean;
        /**
         * Include last point
         * @default false
         */
        includeLast: boolean;
    }
    class PointsOnWireAtPatternOfLengthsDto<T> {
        constructor(shape: T, lengths?: number[], tryNext?: boolean, includeFirst?: boolean, includeLast?: boolean);
        /**
         * Shape representing a wire
         * @default undefined
         */
        shape: T;
        /**
         * length at which to evaluate the point
         * @default undefined
         */
        lengths: number[];
        /**
         * Try next point if the point is not found
         * @default false
         */
        tryNext: boolean;
        /**
         * Include first point
         * @default false
         */
        includeFirst: boolean;
        /**
         * Include last point
         * @default false
         */
        includeLast: boolean;
    }
    class DataOnGeometryAtLengthDto<T> {
        constructor(shape: T, length?: number);
        /**
         * Shape
         * @default undefined
         */
        shape: T;
        /**
         * length at which to evaluate the point
         * @default 0.5
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        length: number;
    }
    class DataOnGeometryesAtLengthDto<T> {
        constructor(shapes: T[], length?: number);
        /**
         * Shapes
         * @default undefined
         */
        shapes: T[];
        /**
         * length at which to evaluate the point
         * @default 0.5
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        length: number;
    }
    class DataOnGeometryAtLengthsDto<T> {
        constructor(shape: T, lengths?: number[]);
        /**
         * Shape representing a wire
         * @default undefined
         */
        shape: T;
        /**
         * lengths at which to evaluate the points
         * @default undefined
         */
        lengths: number[];
    }
    class CircleDto {
        constructor(radius?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Radius of the circle
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Center of the circle
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction vector for circle
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class LoftDto<T> {
        constructor(shapes?: T[], makeSolid?: boolean);
        /**
         * Wires through which the loft passes
         * @default undefined
         */
        shapes: T[];
        /**
         * Tries to make a solid when lofting
         * @default false
         */
        makeSolid: boolean;
    }
    class LoftAdvancedDto<T> {
        constructor(shapes?: T[], makeSolid?: boolean, closed?: boolean, periodic?: boolean, straight?: boolean, nrPeriodicSections?: number, useSmoothing?: boolean, maxUDegree?: number, tolerance?: number, parType?: approxParametrizationTypeEnum, startVertex?: Base.Point3, endVertex?: Base.Point3);
        /**
         * Wires through which the loft passes
         * @default undefined
         */
        shapes: T[];
        /**
         * Tries to make a solid when lofting
         * @default false
         */
        makeSolid: boolean;
        /**
         * Will make a closed loft.
         * @default false
         */
        closed: boolean;
        /**
         * Will make a periodic loft.
         * @default false
         */
        periodic: boolean;
        /**
         * Indicates whether straight sections should be made out of the loft
         * @default false
         */
        straight: boolean;
        /**
         * This number only is used when closed non straight lofting is used
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrPeriodicSections: number;
        /**
         * Tell algorithm to use smoothing
         * @default false
         */
        useSmoothing: boolean;
        /**
         * Maximum u degree
         * @default 3
         */
        maxUDegree: number;
        /**
         * Tolerance
         * @default 1.0e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        tolerance: number;
        /**
         * Approximation parametrization type
         * @default approxCentripetal
         */
        parType: approxParametrizationTypeEnum;
        /**
         * Optional if loft should start with a vertex
         * @default undefined
         * @optional true
         */
        startVertex?: Base.Point3;
        /**
         * Optional if loft should end with a vertex
         * @default undefined
         * @optional true
         */
        endVertex?: Base.Point3;
    }
    class OffsetDto<T, U> {
        constructor(shape?: T, face?: U, distance?: number, tolerance?: number);
        /**
         * Shape to offset
         * @default undefined
         */
        shape: T;
        /**
         * Optionally provide face for the offset
         * @default undefined
         * @optional true
         */
        face?: U;
        /**
         * Distance of offset
         * @default 0.2
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        distance: number;
        /**
         * Offset tolerance
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        tolerance: number;
    }
    class OffsetAdvancedDto<T, U> {
        constructor(shape?: T, face?: U, distance?: number, tolerance?: number, joinType?: joinTypeEnum, removeIntEdges?: boolean);
        /**
         * Shape to offset
         * @default undefined
         */
        shape: T;
        /**
         * Optionally provide face for the offset
         * @default undefined
         * @optional true
         */
        face?: U;
        /**
         * Distance of offset
         * @default 0.2
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        distance: number;
        /**
         * Offset tolerance
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        tolerance: number;
        /**
         * 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
        */
        joinType: joinTypeEnum;
        /**
         * Removes internal edges
         * @default false
         */
        removeIntEdges: boolean;
    }
    class RevolveDto<T> {
        constructor(shape?: T, angle?: number, direction?: Base.Vector3, copy?: boolean);
        /**
         * Shape to revolve
         * @default undefined
         */
        shape: T;
        /**
         * Angle degrees
         * @default 360
         * @minimum 0
         * @maximum 360
         * @step 1
         */
        angle: number;
        /**
         * Direction vector
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * Copy original shape
         * @default false
         */
        copy: boolean;
    }
    class ShapeShapesDto<T, U> {
        constructor(shape?: T, shapes?: U[]);
        /**
         * The wire path
         * @default undefined
         */
        shape: T;
        /**
         * Shapes along the path to be piped
         * @default undefined
         */
        shapes: U[];
    }
    class WiresOnFaceDto<T, U> {
        constructor(wires?: T[], face?: U);
        /**
         * The wires
         * @default undefined
         */
        wires: T[];
        /**
         * Face shape
         * @default undefined
         */
        face: U;
    }
    class PipeWiresCylindricalDto<T> {
        constructor(shapes?: T[], radius?: number, makeSolid?: boolean, trihedronEnum?: geomFillTrihedronEnum, forceApproxC1?: boolean);
        /**
         * Wire paths to pipe
         * @default undefined
         */
        shapes: T[];
        /**
         * Radius of the cylindrical pipe
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        radius: number;
        /**
         * Make solid result by closing start and end parts
         * @default true
         */
        makeSolid: boolean;
        /**
         * Goemetry Fill Trihedron Options
         * @default isConstantNormal
         */
        trihedronEnum: geomFillTrihedronEnum;
        /**
         * Attempt to approximate a C1-continuous surface if a swept surface proved to be C0
         * @default false
         */
        forceApproxC1: boolean;
    }
    class PipeWireCylindricalDto<T> {
        constructor(shape?: T, radius?: number, makeSolid?: boolean, trihedronEnum?: geomFillTrihedronEnum, forceApproxC1?: boolean);
        /**
         * Wire path to pipe
         * @default undefined
         */
        shape: T;
        /**
         * Radius of the cylindrical pipe
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        radius: number;
        /**
         * Make solid result by closing start and end parts
         * @default true
         */
        makeSolid: boolean;
        /**
         * Goemetry Fill Trihedron Options
         * @default isConstantNormal
         */
        trihedronEnum: geomFillTrihedronEnum;
        /**
         * Attempt to approximate a C1-continuous surface if a swept surface proved to be C0
         * @default false
         */
        forceApproxC1: boolean;
    }
    class PipePolygonWireNGonDto<T> {
        constructor(shapes?: T, radius?: number, nrCorners?: number, makeSolid?: boolean, trihedronEnum?: geomFillTrihedronEnum, forceApproxC1?: boolean);
        /**
         * Wire path to pipe
         * @default undefined
         */
        shape: T;
        /**
         * Radius of the cylindrical pipe
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        radius: number;
        /**
         * Nr of ngon corners to be used
         * @default 6
         * @minimum 3
         * @maximum Infinity
         * @step 1
         */
        nrCorners: number;
        /**
         * Make solid result by closing start and end parts
         * @default true
         */
        makeSolid: boolean;
        /**
         * Goemetry Fill Trihedron Options
         * @default isConstantNormal
         */
        trihedronEnum: geomFillTrihedronEnum;
        /**
         * Attempt to approximate a C1-continuous surface if a swept surface proved to be C0
         * @default false
         */
        forceApproxC1: boolean;
    }
    class ExtrudeDto<T> {
        constructor(shape?: T, direction?: Base.Vector3);
        /**
         * Face to extrude
         * @default undefined
         */
        shape: T;
        /**
         * Direction vector for extrusion
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class ExtrudeShapesDto<T> {
        constructor(shapes?: T[], direction?: Base.Vector3);
        /**
         * Shapes to extrude
         * @default undefined
         */
        shapes: T[];
        /**
         * Direction vector for extrusion
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class SplitDto<T> {
        constructor(shape?: T, shapes?: T[]);
        /**
         * Shape to split
         * @default undefined
         */
        shape: T;
        /**
         * Shapes to split from main shape
         * @default undefined
         */
        shapes: T[];
        /**
         * Local fuzzy tolerance used for splitting
         * @default 1.0e-4
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        localFuzzyTolerance: number;
        /**
         * Set to true if you want to split the shape non-destructively
         * @default true
         */
        nonDestructive: boolean;
    }
    class UnionDto<T> {
        constructor(shapes?: T[], keepEdges?: boolean);
        /**
         * Objects to be joined together
         * @default undefined
         */
        shapes: T[];
        /**
         * Keeps edges
         * @default false
         */
        keepEdges: boolean;
    }
    class DifferenceDto<T> {
        constructor(shape?: T, shapes?: T[], keepEdges?: boolean);
        /**
         * Object to subtract from
         * @default undefined
         */
        shape: T;
        /**
         * Objects to subtract
         * @default undefined
         */
        shapes: T[];
        /**
         * Keeps edges unaffected
         * @default false
         */
        keepEdges: boolean;
    }
    class IntersectionDto<T> {
        constructor(shapes?: T[], keepEdges?: boolean);
        /**
         * Shapes to intersect
         * @default undefined
         */
        shapes: T[];
        /**
         * Keep the edges
         * @default false
         */
        keepEdges: boolean;
    }
    class ShapeDto<T> {
        constructor(shape?: T);
        /**
         * Shape on which action should be performed
         * @default undefined
         */
        shape: T;
    }
    class CompareShapesDto<T> {
        constructor(shape?: T, otherShape?: T);
        /**
         * Shape to be compared
         * @default undefined
         */
        shape: T;
        /**
         * Shape to be compared against
         * @default undefined
         */
        otherShape: T;
    }
    class FixSmallEdgesInWireDto<T> {
        constructor(shape?: T, lockvtx?: boolean, precsmall?: number);
        /**
         * Shape on which action should be performed
         * @default undefined
         */
        shape: T;
        /**
         * Lock vertex. If true, the edge must be kept.
         * @default false
         */
        lockvtx: boolean;
        /**
         * Definition of the small distance edge
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.0000000001
         */
        precsmall: number;
    }
    class BasicShapeRepairDto<T> {
        constructor(shape?: T, precision?: number, maxTolerance?: number, minTolerance?: number);
        /**
         * Shape to repair
         * @default undefined
         */
        shape: T;
        /**
         * Basic precision
         * @default 0.001
         * @minimum 0
         * @maximum Infinity
         * @step 0.0000000001
         */
        precision: number;
        /**
         * maximum allowed tolerance. All problems will be detected for cases when a dimension of invalidity is larger than
         * the basic precision or a tolerance of sub-shape on that problem is detected. The maximum tolerance value limits
         * the increasing tolerance for fixing a problem such as fix of not connected and self-intersected wires. If a value
         * larger than the maximum allowed tolerance is necessary for correcting a detected problem the problem can not be fixed.
         * The maximal tolerance is not taking into account during computation of tolerance of edges
         * @default 0.01
         * @minimum 0
         * @maximum Infinity
         * @step 0.0000000001
         */
        maxTolerance: number;
        /**
         * minimal allowed tolerance. It defines the minimal allowed length of edges.
         * Detected edges having length less than the specified minimal tolerance will be removed.
         * @default 0.0001
         * @minimum 0
         * @maximum Infinity
         * @step 0.0000000001
         */
        minTolerance: number;
    }
    class FixClosedDto<T> {
        constructor(shape?: T, precision?: number);
        /**
         * Shape on which action should be performed
         * @default undefined
         */
        shape: T;
        /**
         * Precision for closed wire
         * @default -0.1
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.0000000001
         */
        precision: number;
    }
    class ShapesWithToleranceDto<T> {
        constructor(shapes?: T[], tolerance?: number);
        /**
         * The shapes
         * @default undefined
         */
        shapes: T[];
        /**
         * Tolerance used for intersections
         * @default 1.0e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        tolerance: number;
    }
    class ShapeWithToleranceDto<T> {
        constructor(shape?: T, tolerance?: number);
        /**
         * The shape
         * @default undefined
         */
        shape: T;
        /**
         * Tolerance used for intersections
         * @default 1.0e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        tolerance: number;
    }
    class ShapeIndexDto<T> {
        constructor(shape?: T, index?: number);
        /**
         * Shape
         * @default undefined
         */
        shape: T;
        /**
         * Index of the entity
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        index: number;
    }
    class EdgeIndexDto<T> {
        constructor(shape?: T, index?: number);
        /**
         * Shape
         * @default undefined
         */
        shape: T;
        /**
         * Index of the entity
         * @default 1
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        index: number;
    }
    class RotationExtrudeDto<T> {
        constructor(shape?: T, height?: number, angle?: number, makeSolid?: boolean);
        /**
         * Wire to extrude by rotating
         * @default undefined
         */
        shape: T;
        /**
         * Height of rotation
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Rotation in degrees
         * @default 360
         * @minimum 0
         * @maximum 360
         * @step 1
         */
        angle: number;
        /**
         * Make solid of the result
         * @default true
         */
        makeSolid: boolean;
    }
    class ThickSolidByJoinDto<T> {
        constructor(shape?: T, shapes?: T[], offset?: number, tolerance?: number, intersection?: boolean, selfIntersection?: boolean, joinType?: joinTypeEnum, removeIntEdges?: boolean);
        /**
         * Shape to make thick
         * @default undefined
         */
        shape: T;
        /**
         * closing faces
         * @default undefined
         */
        shapes: T[];
        /**
         * Offset to apply
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        offset: number;
        /**
         * Tolerance defines the tolerance criterion for coincidence in generated shapes
         * @default 1.0e-3
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        tolerance: number;
        /**
         * if Intersection is false (default value), the intersection is calculated with the parallels to the two adjacent shapes
         * @default false
         */
        intersection: boolean;
        /**
         * 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
         */
        selfIntersection: boolean;
        /**
         * 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
        */
        joinType: joinTypeEnum;
        /**
         * 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
         */
        removeIntEdges: boolean;
    }
    class TransformDto<T> {
        constructor(shape?: T, translation?: Base.Vector3, rotationAxis?: Base.Vector3, rotationAngle?: number, scaleFactor?: number);
        /**
         * Shape to transform
         * @default undefined
         */
        shape: T;
        /**
         * Translation to apply
         * @default [0,0,0]
         */
        translation: Base.Vector3;
        /**
         * Rotation to apply
         * @default [0,1,0]
         */
        rotationAxis: Base.Vector3;
        /**
         * Rotation degrees
         * @default 0
         * @minimum 0
         * @maximum 360
         * @step 1
         */
        rotationAngle: number;
        /**
         * Scale factor to apply
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        scaleFactor: number;
    }
    class TransformShapesDto<T> {
        constructor(shapes?: T[], translation?: Base.Vector3[], rotationAxes?: Base.Vector3[], rotationDegrees?: number[], scaleFactors?: number[]);
        /**
         * Shape to transform
         * @default undefined
         */
        shapes: T[];
        /**
         * Translation to apply
         * @default [[0,0,0]]
         */
        translations: Base.Vector3[];
        /**
         * Rotation to apply
         * @default [[0,1,0]]
         */
        rotationAxes: Base.Vector3[];
        /**
         * Rotation degrees
         * @default [0]
         */
        rotationAngles: number[];
        /**
         * Scale factor to apply
         * @default [1]
         */
        scaleFactors: number[];
    }
    class TranslateDto<T> {
        constructor(shape?: T, translation?: Base.Vector3);
        /**
         * Shape for translation
         * @default undefined
         */
        shape: T;
        /**
         * Translation vector
         * @default [0, 0, 0]
         */
        translation: Base.Vector3;
    }
    class TranslateShapesDto<T> {
        constructor(shapes?: T[], translations?: Base.Vector3[]);
        /**
         * Shape for translation
         * @default undefined
         */
        shapes: T[];
        /**
         * Translation vector
         * @default [[0, 0, 0]]
         */
        translations: Base.Vector3[];
    }
    class AlignDto<T> {
        constructor(shape?: T, fromOrigin?: Base.Point3, fromDirection?: Base.Vector3, toOrigin?: Base.Point3, toDirection?: Base.Vector3);
        /**
         * Shape for translation
         * @default undefined
         */
        shape: T;
        /**
         * from origin
         * @default [0, 0, 0]
         */
        fromOrigin: Base.Point3;
        /**
         * From direction
         * @default [0, 0, 1]
         */
        fromDirection: Base.Vector3;
        /**
         * To origin
         * @default [0, 1, 0]
         */
        toOrigin: Base.Point3;
        /**
         * To direction
         * @default [0, 1, 0]
         */
        toDirection: Base.Vector3;
    }
    class AlignShapesDto<T> {
        constructor(shapes?: T[], fromOrigins?: Base.Vector3[], fromDirections?: Base.Vector3[], toOrigins?: Base.Vector3[], toDirections?: Base.Vector3[]);
        /**
         * Shape for translation
         * @default undefined
         */
        shapes: T[];
        /**
         * from origin
         * @default [[0, 0, 0]]
         */
        fromOrigins: Base.Point3[];
        /**
         * From direction
         * @default [[0, 0, 1]]
         */
        fromDirections: Base.Vector3[];
        /**
         * To origin
         * @default [[0, 1, 0]]
         */
        toOrigins: Base.Point3[];
        /**
         * To direction
         * @default [[0, 1, 0]]
         */
        toDirections: Base.Vector3[];
    }
    class MirrorDto<T> {
        constructor(shape?: T, origin?: Base.Point3, direction?: Base.Vector3);
        /**
         * Shape to mirror
         * @default undefined
         */
        shape: T;
        /**
         * Axis origin point
         * @default [0, 0, 0]
         */
        origin: Base.Point3;
        /**
         * Axis direction vector
         * @default [0, 0, 1]
         */
        direction: Base.Vector3;
    }
    class MirrorShapesDto<T> {
        constructor(shapes?: T[], origins?: Base.Point3[], directions?: Base.Vector3[]);
        /**
         * Shape to mirror
         * @default undefined
         */
        shapes: T[];
        /**
         * Axis origin point
         * @default [[0, 0, 0]]
         */
        origins: Base.Point3[];
        /**
         * Axis direction vector
         * @default [[0, 0, 1]]
         */
        directions: Base.Vector3[];
    }
    class MirrorAlongNormalDto<T> {
        constructor(shape?: T, origin?: Base.Point3, normal?: Base.Vector3);
        /**
         * Shape to mirror
         * @default undefined
         */
        shape: T;
        /**
         * Axis origin point
         * @default [0, 0, 0]
         */
        origin: Base.Point3;
        /**
         * First normal axis direction vector
         * @default [0, 0, 1]
         */
        normal: Base.Vector3;
    }
    class MirrorAlongNormalShapesDto<T> {
        constructor(shapes?: T[], origins?: Base.Point3[], normals?: Base.Vector3[]);
        /**
         * Shape to mirror
         * @default undefined
         */
        shapes: T[];
        /**
         * Axis origin point
         * @default [[0, 0, 0]]
         */
        origins: Base.Point3[];
        /**
         * First normal axis direction vector
         * @default [[0, 0, 1]]
         */
        normals: Base.Vector3[];
    }
    class AlignAndTranslateDto<T> {
        constructor(shape?: T, direction?: Base.Vector3, center?: Base.Vector3);
        /**
         * Shape to align and translate
         * @default undefined
         */
        shape: T;
        /**
         * Direction on which to align
         * @default [0, 0, 1]
         */
        direction: Base.Vector3;
        /**
         * Position to translate
         */
        center: Base.Vector3;
    }
    class UnifySameDomainDto<T> {
        constructor(shape?: T, unifyEdges?: boolean, unifyFaces?: boolean, concatBSplines?: boolean);
        /**
         * Shape on which action should be performed
         * @default undefined
         */
        shape: T;
        /**
        * If true, unifies the edges
        * @default true
        */
        unifyEdges: boolean;
        /**
        * If true, unifies the edges
        * @default true
        */
        unifyFaces: boolean;
        /**
        * If true, unifies the edges
        * @default true
        */
        concatBSplines: boolean;
    }
    class FilterFacesPointsDto<T> {
        constructor(shapes?: T[], points?: Base.Point3[], tolerance?: number, useBndBox?: boolean, gapTolerance?: number, keepIn?: boolean, keepOn?: boolean, keepOut?: boolean, keepUnknown?: boolean, flatPointsArray?: boolean);
        /**
         * Face that will be used to filter points
         * @default undefined
         */
        shapes: T[];
        /**
         * Points to filter
         * @default undefined
         */
        points: Base.Point3[];
        /**
         * Tolerance used for filter
         * @default 1.0e-4
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        tolerance: number;
        /**
        * If true, the bounding box will be used to prefilter the points so that there are less points to check on actual face.
        * Recommended to enable if face has more than 10 edges and geometry is mostly spline.
        * This might be faster, but if it is known that points are withing bounding box, this may not be faster.
        * @default false
        */
        useBndBox: boolean;
        /**
         * Gap tolerance
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        gapTolerance: number;
        /**
        * Return points that are inside the face
        * @default true
        */
        keepIn: boolean;
        /**
        * Return points that are on the border of the face
        * @default true
        */
        keepOn: boolean;
        /**
        * Return points that are outside the borders of the face
        * @default false
        */
        keepOut: boolean;
        /**
        * Return points that are classified as unknown
        * @default false
        */
        keepUnknown: boolean;
        /**
         * Returns flat points array by default, otherwise returns points for each face in order provided
         * @default true
         */
        flatPointsArray: boolean;
    }
    class FilterFacePointsDto<T> {
        constructor(shape?: T, points?: Base.Point3[], tolerance?: number, useBndBox?: boolean, gapTolerance?: number, keepIn?: boolean, keepOn?: boolean, keepOut?: boolean, keepUnknown?: boolean);
        /**
         * Face that will be used to filter points
         * @default undefined
         */
        shape: T;
        /**
         * Points to filter
         * @default undefined
         */
        points: Base.Point3[];
        /**
         * Tolerance used for filter
         * @default 1.0e-4
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        tolerance: number;
        /**
        * If true, the bounding box will be used to prefilter the points so that there are less points to check on actual face.
        * Recommended to enable if face has more than 10 edges and geometry is mostly spline.
        * This might be faster, but if it is known that points are withing bounding box, this may not be faster.
        * @default false
        */
        useBndBox: boolean;
        /**
         * Gap tolerance
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        gapTolerance: number;
        /**
        * Return points that are inside the face
        * @default true
        */
        keepIn: boolean;
        /**
        * Return points that are on the border of the face
        * @default true
        */
        keepOn: boolean;
        /**
        * Return points that are outside the borders of the face
        * @default false
        */
        keepOut: boolean;
        /**
        * Return points that are classified as unknown
        * @default false
        */
        keepUnknown: boolean;
    }
    class FilterSolidPointsDto<T> {
        constructor(shape?: T, points?: Base.Point3[], tolerance?: number, keepIn?: boolean, keepOn?: boolean, keepOut?: boolean, keepUnknown?: boolean);
        /**
         * Face that will be used to filter points
         * @default undefined
         */
        shape: T;
        /**
         * Points to filter
         * @default undefined
         */
        points: Base.Point3[];
        /**
         * Tolerance used for filter
         * @default 1.0e-4
         * @minimum 0
         * @maximum Infinity
         * @step 0.000001
         */
        tolerance: number;
        /**
        * Return points that are inside the face
        * @default true
        */
        keepIn: boolean;
        /**
        * Return points that are on the border of the face
        * @default true
        */
        keepOn: boolean;
        /**
        * Return points that are outside the borders of the face
        * @default false
        */
        keepOut: boolean;
        /**
        * Return points that are classified as unknown
        * @default false
        */
        keepUnknown: boolean;
    }
    class AlignAndTranslateShapesDto<T> {
        constructor(shapes?: T[], directions?: Base.Vector3[], centers?: Base.Vector3[]);
        /**
         * Shapes to align and translate
         * @default undefined
         */
        shapes: T[];
        /**
         * Directions on which to align
         * @default [0, 0, 1]
         */
        directions: Base.Vector3[];
        /**
         * Positions to translate
         */
        centers: Base.Vector3[];
    }
    class RotateDto<T> {
        constructor(shape?: T, axis?: Base.Vector3, angle?: number);
        /**
         * Shape to rotate
         * @default undefined
         */
        shape: T;
        /**
         * Axis on which to rotate
         * @default [0, 0, 1]
         */
        axis: Base.Vector3;
        /**
         * Rotation degrees
         * @default 0
         * @minimum 0
         * @maximum 360
         * @step 1
         */
        angle: number;
    }
    class RotateAroundCenterDto<T> {
        constructor(shape?: T, angle?: number, center?: Base.Point3, axis?: Base.Vector3);
        /**
         * Shape to rotate
         * @default undefined
         */
        shape: T;
        /**
         * Angle of rotation to apply
         * @default 0
         */
        angle: number;
        /**
         * Center of the rotation
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Axis around which to rotate
         * @default [0, 0, 1]
         */
        axis: Base.Vector3;
    }
    class RotateShapesDto<T> {
        constructor(shapes?: T[], axes?: Base.Vector3[], angles?: number[]);
        /**
         * Shape to rotate
         * @default undefined
         */
        shapes: T[];
        /**
         * Axis on which to rotate
         * @default [[0, 0, 1]]
         */
        axes: Base.Vector3[];
        /**
         * Rotation degrees
         * @default [0]
         */
        angles: number[];
    }
    class RotateAroundCenterShapesDto<T> {
        constructor(shapes?: T[], angles?: number[], centers?: Base.Point3[], axes?: Base.Vector3[]);
        /**
         * Shape to scale
         * @default undefined
         */
        shapes: T[];
        /**
         * Angles of rotation to apply
         * @default [0]
         */
        angles: number[];
        /**
         * Centers around which to rotate
         * @default [[0, 0, 0]]
         */
        centers: Base.Point3[];
        /**
         * Axes around which to rotate
         * @default [[0, 0, 1]]
         */
        axes: Base.Vector3[];
    }
    class ScaleDto<T> {
        constructor(shape?: T, factor?: number);
        /**
         * Shape to scale
         * @default undefined
         */
        shape: T;
        /**
         * Scale factor to apply
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        factor: number;
    }
    class ScaleShapesDto<T> {
        constructor(shapes?: T[], factors?: number[]);
        /**
         * Shape to scale
         * @default undefined
         */
        shapes: T[];
        /**
         * Scale factor to apply
         * @default [1]
         */
        factors: number[];
    }
    class Scale3DDto<T> {
        constructor(shape?: T, scale?: Base.Vector3, center?: Base.Point3);
        /**
         * Shape to scale
         * @default undefined
         */
        shape: T;
        /**
         * Scale factor to apply
         * @default [1, 1, 1]
         */
        scale: Base.Vector3;
        /**
         * Scale from the center
         * @default [0, 0, 0]
         */
        center: Base.Point3;
    }
    class Scale3DShapesDto<T> {
        constructor(shapes?: T[], scales?: Base.Vector3[], centers?: Base.Point3[]);
        /**
         * Shape to scale
         * @default undefined
         */
        shapes: T[];
        /**
         * Scale factor to apply
         * @default [[1, 1, 1]]
         */
        scales: Base.Vector3[];
        /**
         * Scale from the center
         * @default [[0, 0, 0]]
         */
        centers: Base.Point3[];
    }
    class ShapeToMeshDto<T> {
        constructor(shape?: T, precision?: number, adjustYtoZ?: boolean);
        /**
         * Shape to save
         * @default undefined
         */
        shape: T;
        /**
         * Precision of the mesh
         * @default 0.01
         * @minimum 0
         * @maximum Infinity
         * @step 0.001
         */
        precision: number;
        /**
         * Adjust Y (up) coordinate system to Z (up) coordinate system
         * @default false
         */
        adjustYtoZ: boolean;
    }
    class ShapesToMeshesDto<T> {
        constructor(shapes?: T[], precision?: number, adjustYtoZ?: boolean);
        /**
         * Shapes to transform
         * @default undefined
         */
        shapes: T[];
        /**
         * Precision of the mesh
         * @default 0.01
         * @minimum 0
         * @maximum Infinity
         * @step 0.001
         */
        precision: number;
        /**
         * Adjust Y (up) coordinate system to Z (up) coordinate system
         * @default false
         */
        adjustYtoZ: boolean;
    }
    class SaveStepDto<T> {
        constructor(shape?: T, fileName?: string, adjustYtoZ?: boolean, tryDownload?: boolean);
        /**
         * Shape to save
         * @default undefined
         */
        shape: T;
        /**
         * File name
         * @default shape.step
         */
        fileName: string;
        /**
         * Adjust Y (up) coordinate system to Z (up) coordinate system
         * @default false
         */
        adjustYtoZ: boolean;
        /**
         * Will attempt to downlaod the file if that is possible
         * @default true
         */
        tryDownload?: boolean;
    }
    class SaveStlDto<T> {
        constructor(shape?: T, fileName?: string, precision?: number, adjustYtoZ?: boolean, tryDownload?: boolean, binary?: boolean);
        /**
         * Shape to save
         * @default undefined
         */
        shape: T;
        /**
         * File name
         * @default shape.stl
         */
        fileName: string;
        /**
         * Precision of the mesh - lower means higher res
         * @default 0.01
         */
        precision: number;
        /**
         * Adjust Y (up) coordinate system to Z (up) coordinate system
         * @default false
         */
        adjustYtoZ: boolean;
        /**
         * Try download the file if that is possible
         * @default true
         */
        tryDownload?: boolean;
        /**
         * Generate binary STL file
         * @default true
         */
        binary?: boolean;
    }
    class ImportStepIgesFromTextDto {
        constructor(text?: string, fileType?: fileTypeEnum, adjustZtoY?: boolean);
        /**
         * The text that represents step or iges contents
         * @default undefined
         */
        text: string;
        /**
         * Identify the import type
         */
        fileType: fileTypeEnum;
        /**
         * Adjusts models that use Z coordinate as up to Y up system.
         * @default true
         */
        adjustZtoY: boolean;
    }
    class ImportStepIgesDto {
        constructor(assetFile?: File, adjustZtoY?: boolean);
        /**
         * The name of the asset to store in the cache.
         * This allows to store the imported objects for multiple run cycles in the cache
         * @default undefined
         */
        assetFile: File;
        /**
         * Adjusts models that use Z coordinate as up to Y up system.
         * @default true
         */
        adjustZtoY: boolean;
    }
    class LoadStepOrIgesDto {
        constructor(filetext?: string | ArrayBuffer, fileName?: string, adjustZtoY?: boolean);
        /**
         * File text
         * @default undefined
         */
        filetext: string | ArrayBuffer;
        /**
         * File name
         * @default shape.igs
         */
        fileName: string;
        /**
         * Adjusts models that use Z coordinate as up to Y up system.
         * @default true
         */
        adjustZtoY: boolean;
    }
    class CompoundShapesDto<T> {
        constructor(shapes?: T[]);
        /**
         * Shapes to add to compound
         * @default undefined
         */
        shapes: T[];
    }
    class ThisckSolidSimpleDto<T> {
        constructor(shape?: T, offset?: number);
        /**
         * Shape to make thick
         * @default undefined
         */
        shape: T;
        /**
         * Offset distance
         * @default 1
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        offset: number;
    }
    class Offset3DWireDto<T> {
        constructor(shape?: T, offset?: number, direction?: Base.Vector3);
        /**
         * Shape to make thick
         * @default undefined
         */
        shape: T;
        /**
         * Offset distance
         * @default 1
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        offset: number;
        /**
         * Direction normal of the plane for the offset
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class FaceFromWireDto<T> {
        constructor(shape?: T, planar?: boolean);
        /**
         * Wire shape to convert into a face
         * @default undefined
         */
        shape: T;
        /**
         * Should plane be planar
         * @default false
         */
        planar: boolean;
    }
    class FaceFromWireOnFaceDto<T, U> {
        constructor(wire?: T, face?: U, inside?: boolean);
        /**
         * Wire shape to convert into a face
         * @default undefined
         */
        wire: T;
        /**
         * Face to attach the wire to
         * @default undefined
         */
        face: U;
        /**
         * Indication if wire is inside the surface or outside
         * @default true
         */
        inside: boolean;
    }
    class FacesFromWiresOnFaceDto<T, U> {
        constructor(wires?: T[], face?: U, inside?: boolean);
        /**
         * Wire shape to convert into a face
         * @default undefined
         */
        wires: T[];
        /**
         * Face to attach the wires to
         * @default undefined
         */
        face: U;
        /**
         * Indication if wire is inside the surface or outside
         * @default true
         */
        inside: boolean;
    }
    class FaceFromWiresDto<T> {
        constructor(shapes?: T[], planar?: boolean);
        /**
         * Wire shapes to convert into a faces
         * @default undefined
         */
        shapes: T[];
        /**
         * Should plane be planar
         * @default false
         */
        planar: boolean;
    }
    class FacesFromWiresDto<T> {
        constructor(shapes?: T[], planar?: boolean);
        /**
         * Wire shapes to convert into a faces
         * @default undefined
         */
        shapes: T[];
        /**
         * Should plane be planar
         * @default false
         */
        planar: boolean;
    }
    class FaceFromWiresOnFaceDto<T, U> {
        constructor(wires?: T[], face?: U, inside?: boolean);
        /**
         * Wire shapes to convert into a faces
         * @default undefined
         */
        wires: T[];
        /**
         * Guide face to use as a base
         * @default undefined
         */
        face: U;
        /**
         * Indication if wire is inside the surface or outside
         * @default true
         */
        inside: boolean;
    }
    class SewDto<T> {
        constructor(shapes: T[], tolerance?: number);
        /**
         * Faces to construct a shell from
         * @default undefined
         */
        shapes: T[];
        /**
         * Tolerance of sewing
         * @default 1.0e-7
         * @minimum 0
         * @maximum Infinity
         * @step 0.00001
         */
        tolerance: number;
    }
    class FaceIsoCurveAtParamDto<T> {
        constructor(shape?: T, param?: number, dir?: "u" | "v");
        /**
         * Face shape
         * @default undefined
         */
        shape: T;
        /**
         * Param at which to find isocurve
         * @default 0.5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        param: number;
        /**
         * Direction to find the isocurve
         * @default u
         */
        dir: "u" | "v";
    }
    class DivideFaceToUVPointsDto<T> {
        constructor(shape?: T, nrOfPointsU?: number, nrOfPointsV?: number, flat?: boolean);
        /**
         * Face shape
         * @default undefined
         */
        shape: T;
        /**
         * Number of points on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrOfPointsU: number;
        /**
         * Number of points on V direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrOfPointsV: number;
        /**
         * Flatten the output
         * @default false
         */
        flat: boolean;
    }
    class Geom2dEllipseDto {
        constructor(center?: Base.Point2, direction?: Base.Vector2, radiusMinor?: number, radiusMajor?: number, sense?: boolean);
        /**
         * Center of the ellipse
         * @default [0,0]
         */
        center: Base.Point2;
        /**
         * Direction of the vector
         * @default [1,0]
         */
        direction: Base.Vector2;
        /**
         * Minor radius of an ellipse
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radiusMinor: number;
        /**
         * Major radius of an ellipse
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radiusMajor: number;
        /**
         * If true will sense the direction
         * @default false
         */
        sense: boolean;
    }
    class Geom2dCircleDto {
        constructor(center?: Base.Point2, direction?: Base.Vector2, radius?: number, sense?: boolean);
        /**
         * Center of the circle
         * @default [0,0]
         */
        center: Base.Point2;
        /**
         * Direction of the vector
         * @default [1,0]
         */
        direction: Base.Vector2;
        /**
         * Radius of the circle
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * If true will sense the direction
         * @default false
         */
        sense: boolean;
    }
    class ChristmasTreeDto {
        constructor(height?: number, innerDist?: number, outerDist?: number, nrSkirts?: number, trunkHeight?: number, trunkWidth?: number, half?: boolean, rotation?: number, origin?: Base.Point3, direction?: Base.Vector3);
        /**
         * Height of the tree
         * @default 6
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Inner distance of the branches on the bottom of the tree
         * @default 1.5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        innerDist: number;
        /**
         * Outer distance of the branches on the bottom of the tree
         * @default 3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        outerDist: number;
        /**
         * Number of skirts on the tree (triangle like shapes)
         * @default 5
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrSkirts: number;
        /**
         * Trunk height
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        trunkHeight: number;
        /**
         * Trunk width only applies if trunk height is more than 0
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        trunkWidth: number;
        /**
         * Indicates wether only a half of the tree should be created
         * @default false
         */
        half: boolean;
        /**
         * Rotation of the tree
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 15
         */
        rotation: number;
        /**
         * Origin of the tree
         * @default [0, 0, 0]
         */
        origin: Base.Point3;
        /**
         * Direction of the tree
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class StarDto {
        constructor(outerRadius?: number, innerRadius?: number, numRays?: number, center?: Base.Point3, direction?: Base.Vector3, offsetOuterEdges?: number, half?: boolean);
        /**
         * Center of the circle
         * @default [0,0,0]
         */
        center: Base.Point3;
        /**
         * Direction
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * Direction of the vector
         * @default 7
         * @minimum 3
         * @maximum Infinity
         * @step 1
         */
        numRays: number;
        /**
         * Angle of the rays
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        outerRadius: number;
        /**
         * Angle of the rays
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        innerRadius: number;
        /**
         * Offsets outer edge cornerners along the direction vector
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        offsetOuterEdges?: number;
        /**
         * Construct half of the star
         * @default false
         */
        half: boolean;
    }
    class ParallelogramDto {
        constructor(center?: Base.Point3, direction?: Base.Vector3, aroundCenter?: boolean, width?: number, height?: number, angle?: number);
        /**
         * Center of the circle
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * Indicates whether to draw the parallelogram around the center point or start from corner.
         * @default true
         */
        aroundCenter: boolean;
        /**
         * Width of bounding rectangle
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width: number;
        /**
         * Height of bounding rectangle
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Sharp angle of the parallelogram
         * @default 15
         * @minimum -Infinity
         * @maximum Infinity
         * @step 1
         */
        angle: number;
    }
    class Heart2DDto {
        constructor(center?: Base.Point3, direction?: Base.Vector3, rotation?: number, sizeApprox?: number);
        /**
         * Center of the circle
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * Rotation of the hear
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 15
         */
        rotation: number;
        /**
         * Size of the bounding box within which the heart gets drawn
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        sizeApprox: number;
    }
    class NGonWireDto {
        constructor(center?: Base.Point3, direction?: Base.Vector3, nrCorners?: number, radius?: number);
        /**
         * Center of the circle
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * How many corners to create.
         * @default 6
         * @minimum 3
         * @maximum Infinity
         * @step 1
         */
        nrCorners: number;
        /**
         * Radius of nGon
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
    }
    class EllipseDto {
        constructor(center?: Base.Point3, direction?: Base.Vector3, radiusMinor?: number, radiusMajor?: number);
        /**
         * Center of the ellipse
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the vector
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * Minor radius of an ellipse
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radiusMinor: number;
        /**
         * Major radius of an ellipse
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radiusMajor: number;
    }
    class GeomCylindricalSurfaceDto {
        constructor(radius?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Radius of the cylindrical surface
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Center of the cylindrical surface
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Axis of direction for cylindrical surface
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class Geom2dTrimmedCurveDto<T> {
        constructor(shape?: T, u1?: number, u2?: number, sense?: boolean, adjustPeriodic?: boolean);
        /**
         * 2D Curve to trim
         * @default undefined
         */
        shape: T;
        /**
         * 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
         */
        u1: number;
        /**
         * Second parameter on the curve for trimming
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        u2: number;
        /**
         *  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
         */
        sense: boolean;
        /**
         * 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
         */
        adjustPeriodic: boolean;
    }
    class Geom2dSegmentDto {
        constructor(start?: Base.Point2, end?: Base.Point2);
        /**
         * Start 2d point for segment
         * @default [0, 0]
         */
        start: Base.Point2;
        /**
         * End 2d point for segment
         * @default [1, 0]
         */
        end: Base.Point2;
    }
    class SliceDto<T> {
        constructor(shape?: T, step?: number, direction?: Base.Vector3);
        /**
         * The shape to slice
         * @default undefined
         */
        shape: T;
        /**
         * Step at which to divide the shape
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        step: number;
        /**
         * Direction vector
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class SliceInStepPatternDto<T> {
        constructor(shape?: T, steps?: number[], direction?: Base.Vector3);
        /**
         * The shape to slice
         * @default undefined
         */
        shape: T;
        /**
         * Steps that should be used for slicing. This array is going to be treated as a pattern -
         * this menas that if the actual number of steps is lower than the number of steps in the pattern, the pattern will be repeated.
         * @default [0.1, 0.2]
         */
        steps: number[];
        /**
         * Direction vector
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
}