import { Base } from "@bitbybit-dev/base";
import { IO } from "@bitbybit-dev/base/lib/api/inputs/io-inputs";
import * as Models from "../models";
export declare namespace OCCT {
    type GeomCurvePointer = {
        hash: number;
        type: "occ-shape";
    };
    type Geom2dCurvePointer = {
        hash: number;
        type: "occ-shape";
    };
    type GeomSurfacePointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSVertexPointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSEdgePointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSWirePointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSFacePointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSShellPointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSSolidPointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSCompSolidPointer = {
        hash: number;
        type: "occ-shape";
    };
    type TopoDSCompoundPointer = {
        hash: number;
        type: "occ-shape";
    };
    type TDocStdDocumentPointer = {
        hash: number;
        type: "occ-entity";
    };
    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"
    }
    enum dxfColorFormatEnum {
        aci = "aci",
        truecolor = "truecolor"
    }
    enum dxfAcadVersionEnum {
        AC1009 = "AC1009",
        AC1015 = "AC1015"
    }
    enum dimensionEndTypeEnum {
        none = "none",
        arrow = "arrow"
    }
    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, drawTwoSided?: boolean, backFaceColour?: Base.Color, backFaceOpacity?: number);
        /**
         * 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;
        /**
         * Draw two-sided faces with different colors for front and back. This helps visualize face orientation.
         * @default true
         */
        drawTwoSided: boolean;
        /**
         * Hex colour string for back face colour (negative side of the face). Only used when drawTwoSided is true.
         * @default #0000ff
         */
        backFaceColour: Base.Color;
        /**
         * Back face opacity value between 0 and 1. Only used when drawTwoSided is true.
         * @default 1
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        backFaceOpacity: number;
    }
    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, drawTwoSided?: boolean, backFaceColour?: Base.Color, backFaceOpacity?: number);
        /**
         * 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;
        /**
         * Draw two-sided faces with different colors for front and back. This helps visualize face orientation.
         * @default true
         */
        drawTwoSided: boolean;
        /**
         * Hex colour string for back face colour (negative side of the face). Only used when drawTwoSided is true.
         * @default #0000ff
         */
        backFaceColour: Base.Color;
        /**
         * Back face opacity value between 0 and 1. Only used when drawTwoSided is true.
         * @default 1
         * @minimum 0
         * @maximum 1
         * @step 0.1
         */
        backFaceOpacity: number;
    }
    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 FaceSubdivideToHexagonWiresDto<T> {
        /**
          * Provide options without default values
          */
        constructor(shape?: T, nrHexagonsU?: number, nrHexagonsV?: number, flatU?: boolean, scalePatternU?: number[], scalePatternV?: number[], filletPattern?: number[], inclusionPattern?: boolean[], offsetFromBorderU?: number, offsetFromBorderV?: number, extendUUp?: boolean, extendUBottom?: boolean, extendVUp?: boolean, extendVBottom?: boolean);
        /**
         * Openascade Face
         * @default undefined
         */
        shape?: T;
        /**
         * Number of hexagons on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrHexagonsU?: number;
        /**
         * Number of hexagons on V direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrHexagonsV?: number;
        flatU: boolean;
        /**
         * Hexagon 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[];
        /**
         * Hexagon 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[];
        /**
         * Hexagon 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 shortest segment of the hexagon
         * @default undefined
         * @optional true
         */
        filletPattern?: number[];
        /**
         * Hexagon inclusion pattern - true means that the hexagon will be included,
         * false means that the hexagon 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 hexagons to be placed. This means that even hexagon 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 hexagons to be placed. This means that even hexagon 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;
        /**
         * If true, we will extend the hexagons beyond the face u up border by their pointy tops
         * @default false
         */
        extendUUp?: boolean;
        /**
         * If true, we will extend the hexagons beyond the face u bottom border by their pointy tops
         * @default false
         */
        extendUBottom?: boolean;
        /**
         * If true, we will extend the hexagons beyond the face v upper border by their half width
         * @default false
         */
        extendVUp?: boolean;
        /**
         * If true, we will extend the hexagons beyond the face v bottom border by their half width
         * @default false
         */
        extendVBottom?: boolean;
    }
    class FaceSubdivideToHexagonHolesDto<T> {
        /**
          * Provide options without default values
          */
        constructor(shape?: T, nrHexagonsU?: number, nrHexagonsV?: number, flatU?: boolean, holesToFaces?: boolean, scalePatternU?: number[], scalePatternV?: number[], filletPattern?: number[], inclusionPattern?: boolean[], offsetFromBorderU?: number, offsetFromBorderV?: number);
        /**
         * Openascade Face
         * @default undefined
         */
        shape?: T;
        /**
         * Number of hexagons on U direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrHexagonsU?: number;
        /**
         * Number of hexagons on V direction
         * @default 10
         * @minimum 1
         * @maximum Infinity
         * @step 1
         */
        nrHexagonsV?: number;
        flatU: boolean;
        /**
         * If true, we will also create holes as faces
         * @default false
         */
        holesToFaces?: boolean;
        /**
         * Hexagon 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[];
        /**
         * Hexagon 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[];
        /**
         * Hexagon 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 shortest segment of the hexagon
         * @default undefined
         * @optional true
         */
        filletPattern?: number[];
        /**
         * Hexagon inclusion pattern - true means that the hexagon will be included,
         * false means that the hexagon 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 hexagons to be placed. This means that even hexagon 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 hexagons to be placed. This means that even hexagon 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 PolylineBaseDto {
        constructor(polyline?: Base.Polyline3);
        /**
         * Polyline
         * @default undefined
         */
        polyline: Base.Polyline3;
    }
    class PolylinesBaseDto {
        constructor(polylines?: Base.Polyline3[]);
        /**
         * Polylines
         * @default undefined
         */
        polylines: Base.Polyline3[];
    }
    class LineBaseDto {
        constructor(line?: Base.Line3);
        /**
         * Line
         * @default undefined
         */
        line: Base.Line3;
    }
    class LinesBaseDto {
        constructor(lines?: Base.Line3[]);
        /**
         * Lines
         * @default undefined
         */
        lines: Base.Line3[];
    }
    class SegmentBaseDto {
        constructor(segment?: Base.Segment3);
        /**
         * Segment
         * @default undefined
         */
        segment: Base.Segment3;
    }
    class SegmentsBaseDto {
        constructor(segments?: Base.Segment3[]);
        /**
         * Segments
         * @default undefined
         */
        segments: Base.Segment3[];
    }
    class TriangleBaseDto {
        constructor(triangle?: Base.Triangle3);
        /**
         * Triangle
         * @default undefined
         */
        triangle: Base.Triangle3;
    }
    class MeshBaseDto {
        constructor(mesh?: Base.Mesh3);
        /**
         * Mesh
         * @default undefined
         */
        mesh: Base.Mesh3;
    }
    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 IBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Width of the I-beam (flange width)
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width: number;
        /**
         * Height of the I-beam
         * @default 3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Thickness of the web (vertical part)
         * @default 0.2
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        webThickness: number;
        /**
         * Thickness of the flanges (horizontal parts)
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        flangeThickness: number;
        /**
         * Alignment of the profile origin
         * @default midMid
         */
        alignment: Base.basicAlignmentEnum;
        /**
         * Rotation of the I-beam profile in degrees
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 15
         */
        rotation: number;
        /**
         * Center of the I-beam profile
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the I-beam profile
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class HBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Width of the H-beam (flange width)
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width: number;
        /**
         * Height of the H-beam
         * @default 3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Thickness of the web (vertical part)
         * @default 0.2
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        webThickness: number;
        /**
         * Thickness of the flanges (horizontal parts)
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        flangeThickness: number;
        /**
         * Alignment of the profile origin
         * @default midMid
         */
        alignment: Base.basicAlignmentEnum;
        /**
         * Rotation of the H-beam profile in degrees
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 15
         */
        rotation: number;
        /**
         * Center of the H-beam profile
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the H-beam profile
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class TBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Width of the T-beam (flange width)
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width: number;
        /**
         * Height of the T-beam
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Thickness of the web (vertical part)
         * @default 0.2
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        webThickness: number;
        /**
         * Thickness of the flange (horizontal part)
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        flangeThickness: number;
        /**
         * Alignment of the profile origin
         * @default midMid
         */
        alignment: Base.basicAlignmentEnum;
        /**
         * Rotation of the T-beam profile in degrees
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 15
         */
        rotation: number;
        /**
         * Center of the T-beam profile
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the T-beam profile
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class UBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, flangeWidth?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Overall width of the U-beam
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width: number;
        /**
         * Height of the U-beam
         * @default 3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Thickness of the web (back part)
         * @default 0.2
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        webThickness: number;
        /**
         * Thickness of the flanges (side parts)
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        flangeThickness: number;
        /**
         * Width of the flanges (how far they extend inward)
         * @default 0.5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        flangeWidth: number;
        /**
         * Alignment of the profile origin
         * @default midMid
         */
        alignment: Base.basicAlignmentEnum;
        /**
         * Rotation of the U-beam profile in degrees
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 15
         */
        rotation: number;
        /**
         * Center of the U-beam profile
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the U-beam profile
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class ExtrudedSolidDto {
        constructor(extrusionLengthFront?: number, extrusionLengthBack?: number, center?: Base.Point3, direction?: Base.Vector3);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
        /**
         * Center of the solid
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of extrusion
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
    }
    class IBeamProfileSolidDto extends IBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class HBeamProfileSolidDto extends HBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class TBeamProfileSolidDto extends TBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class UBeamProfileSolidDto extends UBeamProfileDto {
        constructor(width?: number, height?: number, webThickness?: number, flangeThickness?: number, flangeWidth?: number, alignment?: Base.basicAlignmentEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    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 TorusDto {
        constructor(majorRadius?: number, minorRadius?: number, center?: Base.Point3, direction?: Base.Vector3, angle?: number);
        /**
         * Major radius (distance from the center of the torus to the center of the pipe)
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        majorRadius: number;
        /**
         * Minor radius (radius of the pipe)
         * @default 0.5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        minorRadius: number;
        /**
         * Center of the torus
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction (axis) of the torus
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * Angle of the torus segment in degrees (360 for full torus)
         * @default 360
         * @minimum 0
         * @maximum 360
         * @step 1
         */
        angle?: number;
    }
    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 LineWithExtensionsDto {
        constructor(start?: Base.Point3, end?: Base.Point3, extensionStart?: number, extensionEnd?: number);
        /**
         * Start of the line
         * @default [0, 0, 0]
         */
        start: Base.Point3;
        /**
         * End of the line
         * @default [0, 1, 0]
         */
        end: Base.Point3;
        /**
         * Extension of the line on the start
         * @default 0.1
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        extensionStart: number;
        /**
         * Extension of the line on the end
         * @default 0.1
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        extensionEnd: number;
    }
    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 HexagonsInGridDto {
        constructor(wdith?: number, height?: number, nrHexagonsInHeight?: number, nrHexagonsInWidth?: number, flatTop?: boolean, extendTop?: boolean, extendBottom?: boolean, extendLeft?: boolean, extendRight?: boolean, scalePatternWidth?: number[], scalePatternHeight?: number[], filletPattern?: number[], inclusionPattern?: boolean[]);
        /** Total desired width for the grid area. The hexagon size will be derived from this and nrHexagonsU.
         * @default 10
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        width?: number;
        /** Total desired height for the grid area. Note: due to hexagon geometry, the actual grid height might differ slightly if maintaining regular hexagons based on width.
         * @default 10
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
        */
        height?: number;
        /** Number of hexagons desired in width.
         * @default 10
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        nrHexagonsInWidth?: number;
        /** Number of hexagons desired in height.
         * @default 10
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        nrHexagonsInHeight?: number;
        /** If true, the hexagons will be oriented with their flat sides facing up and down.
         * @default false
         */
        flatTop?: boolean;
        /** If true, shift the entire grid up by half hex height.
         * @default false
        */
        extendTop?: boolean;
        /** If true, shift the entire grid down by half hex height.
         * @default false
        */
        extendBottom?: boolean;
        /** If true, shift the entire grid left by half hex width.
         * @default false
        */
        extendLeft?: boolean;
        /** If true, shift the entire grid right by half hex width.
         * @default false
        */
        extendRight?: boolean;
        /**
         * Hex scale pattern on width direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
         * @default undefined
         * @optional true
         */
        scalePatternWidth?: number[];
        /**
         * Hex scale pattern on height direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
         * @default undefined
         * @optional true
         */
        scalePatternHeight?: number[];
        /**
         * Hex 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 hex
         * @default undefined
         * @optional true
         */
        filletPattern?: number[];
        /**
         * Inclusion pattern - true means that the hex will be included,
         * false means that the hex will be removed
         * @default undefined
         * @optional true
         */
        inclusionPattern?: boolean[];
    }
    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 MeshMeshIntersectionTwoShapesDto<T> {
        constructor(shape1?: T, shape2?: T, precision1?: number, precision2?: number);
        /**
         * First shape to be used for intersection
         * @default undefined
         */
        shape1: T;
        /**
         * Precision of first shape to be used for meshing and computing intersection.
         * Keep in mind that the lower this value is, the more triangles will be produced and thus the slower the computation.
         * @default 0.01
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        precision1?: number;
        /**
         * Second shape to be used for intersection
         * @default undefined
         */
        shape2: T;
        /**
         * Precision of second shape to be used for meshing and computing intersection.
         * Keep in mind that the lower this value is, the more triangles will be produced and thus the slower the computation.
         * @default 0.01
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        precision2?: number;
    }
    class MeshMeshesIntersectionOfShapesDto<T> {
        constructor(shape?: T, shapes?: T[], precision?: number, precisionShapes?: number[]);
        /**
         * Shape to use for the base of computations
         * @default undefined
         */
        shape?: T;
        /**
         * Precision of first shape to be used for meshing and computing intersection.
         * Keep in mind that the lower this value is, the more triangles will be produced and thus the slower the computation.
         * @default 0.01
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        precision?: number;
        /**
         * Second shape to be used for intersection
         * @default undefined
         */
        shapes?: T[];
        /**
         * Precision of shapes to be used, if undefined, a universal precision will be used of the first shape
         * @default undefined
         * @optional true
         */
        precisionShapes?: number[];
    }
    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 0
         * @minimum 0
         * @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 AlignNormAndAxisDto<T> {
        constructor(shape?: T, fromOrigin?: Base.Point3, fromNorm?: Base.Vector3, fromAx?: Base.Vector3, toOrigin?: Base.Point3, toNorm?: Base.Vector3, toAx?: Base.Vector3);
        /**
         * Shape for translation
         * @default undefined
         */
        shape: T;
        /**
         * from origin
         * @default [0, 0, 0]
         */
        fromOrigin: Base.Point3;
        /**
         * From direction 1
         * @default [0, 0, 1]
         */
        fromNorm: Base.Vector3;
        /**
         * From direction 2
         * @default [0, 0, 1]
         */
        fromAx: Base.Vector3;
        /**
         * To origin
         * @default [0, 1, 0]
         */
        toOrigin: Base.Point3;
        /**
         * To direction 1
         * @default [0, 1, 0]
         */
        toNorm: Base.Vector3;
        /**
         * To direction 2
         * @default [0, 0, 1]
         */
        toAx: 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 ShapeFacesToPolygonPointsDto<T> {
        constructor(shape?: T, precision?: number, adjustYtoZ?: boolean, reversedPoints?: 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;
        /**
         * Reverse the order of the points describing the polygon because some CAD kernels use the opposite order
         * @default false
         */
        reversedPoints: 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 assume that the shape is created in right handed coordinate system environment
         * and will compensate by not mirroring the shape along z axis
         * @default false
         */
        fromRightHanded?: boolean;
        /**
         * Will attempt to download the file if that is possible, keep in mind that you might need to implement this yourself. In bitbybit this is handled by worker layers which only run in browsers.
         * @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;
        /**
         * Will attempt to download the file if that is possible, keep in mind that you might need to implement this yourself. In bitbybit this is handled by worker layers which only run in browsers.
         * @default true
         */
        tryDownload?: boolean;
        /**
         * Generate binary STL file
         * @default true
         */
        binary?: boolean;
    }
    class ShapeToDxfPathsDto<T> {
        constructor(shape?: T, angularDeflection?: number, curvatureDeflection?: number, minimumOfPoints?: number, uTolerance?: number, minimumLength?: number);
        /**
         * Shape to convert to DXF paths
         * @default undefined
         */
        shape: T;
        /**
         * The angular deflection for curve tessellation
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.01
         */
        angularDeflection: number;
        /**
         * The curvature deflection for curve tessellation
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.001
         */
        curvatureDeflection: number;
        /**
         * Minimum of points for curve tessellation
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        minimumOfPoints: number;
        /**
         * U tolerance for curve tessellation
         * @default 1.0e-9
         * @minimum 0
         * @maximum Infinity
         * @step 1.0e-9
         */
        uTolerance: number;
        /**
         * Minimum length for curve tessellation
         * @default 1.0e-7
         * @minimum 0
         * @maximum Infinity
         * @step 1.0e-7
         */
        minimumLength: number;
    }
    class DxfPathsWithLayerDto {
        constructor(paths?: IO.DxfPathDto[], layer?: string, color?: Base.Color);
        /**
         * Array of DXF paths (output from shapeToDxfPaths)
         * @default undefined
         */
        paths: IO.DxfPathDto[];
        /**
         * Layer name for these paths
         * @default Default
         */
        layer: string;
        /**
         * Color for these paths
         * @default #000000
         */
        color: Base.Color;
    }
    class DxfPathsPartsListDto {
        constructor(pathsParts?: IO.DxfPathsPartDto[], colorFormat?: dxfColorFormatEnum, acadVersion?: dxfAcadVersionEnum, tryDownload?: boolean);
        /**
         * Array of DXF paths parts (output from dxfPathsWithLayer)
         * @default undefined
         */
        pathsParts: IO.DxfPathsPartDto[];
        /**
         * Color format to use in the DXF file
         * @default aci
         */
        colorFormat: dxfColorFormatEnum;
        /**
         * AutoCAD version format for DXF file
         * @default AC1009
         */
        acadVersion: dxfAcadVersionEnum;
        /**
         * File name
         * @default bitbybit-dev.dxf
         */
        fileName?: string;
        /**
         * Will attempt to download the file if that is possible, keep in mind that you might need to implement this yourself. In bitbybit this is handled by worker layers which only run in browsers.
         * @default true
         */
        tryDownload?: boolean;
    }
    class SaveDxfDto<T> {
        constructor(shape?: T, fileName?: string, tryDownload?: boolean, angularDeflection?: number, curvatureDeflection?: number, minimumOfPoints?: number, uTolerance?: number, minimumLength?: number);
        /**
         * Shape to save
         * @default undefined
         */
        shape: T;
        /**
         * File name
         * @default shape.dxf
         */
        fileName: string;
        /**
         * Will attempt to download the file if that is possible, keep in mind that you might need to implement this yourself. In bitbybit this is handled by worker layers which only run in browsers.
         * @default true
         */
        tryDownload?: boolean;
        /**
         * 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 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;
    }
    /**
     * Options for loading STEP or IGES files.
     * Accepts text content (string) for plain files, or binary content (ArrayBuffer) for compressed files.
     */
    class LoadStepOrIgesDto {
        constructor(filetext?: string | ArrayBuffer, fileName?: string, adjustZtoY?: boolean);
        /**
         * File content:
         * - string: for plain text files (.step, .stp, .iges, .igs)
         * - ArrayBuffer: for compressed files (.stpz, .igz)
         * @default undefined
         */
        filetext: string | ArrayBuffer;
        /**
         * File name (used to determine file type)
         * @default shape.step
         */
        fileName: string;
        /**
         * Adjusts models that use Z coordinate as up to Y up system.
         * @default true
         */
        adjustZtoY: boolean;
    }
    /**
     * Options for parsing STEP assemblies to JSON using native C++ XCAF traversal.
     * This is the fast, native approach that runs entirely in C++.
     */
    class ParseStepAssemblyToJsonDto {
        constructor(stepData?: string | ArrayBuffer | Uint8Array | File | Blob);
        /**
         * STEP data as string (for plain text files), ArrayBuffer, Uint8Array, File, or Blob.
         * Supports compressed .stpz files - gzip-compressed data is automatically decompressed.
         * @default undefined
         */
        stepData: string | ArrayBuffer | Uint8Array | File | Blob;
    }
    /**
     * Options for converting STEP to glTF format.
     * Uses native OCCT RWGltf_CafWriter for fast conversion with full attribute preservation.
     */
    class ConvertStepToGltfDto {
        constructor(stepData?: string | ArrayBuffer | Uint8Array | File | Blob);
        /**
         * STEP data as string (for plain text files), ArrayBuffer, Uint8Array, File, or Blob.
         * Supports compressed .stpz files - gzip-compressed data is automatically decompressed.
         * @default undefined
         */
        stepData: string | ArrayBuffer | Uint8Array | File | Blob;
        /**
         * Mesh linear deflection (triangulation precision).
         * When `meshRelative` is true (default), this is a fraction of each edge's length
         * (e.g. 0.005 = 0.5%) so small parts get fine meshes and large parts get coarse ones.
         * When `meshRelative` is false, this is an absolute value in model units (mm for STEP).
         * @default 0.005
         * @minimum 0.0001
         * @maximum 10
         * @step 0.001
         */
        meshPrecision: number;
        /**
         * Mesh angular deflection in radians (max normal deviation between adjacent triangles).
         * Smaller values produce smoother curved surfaces but more triangles.
         * @default 0.5
         * @minimum 0.01
         * @maximum 3.14159
         * @step 0.05
         */
        meshAngle: number;
        /**
         * Use size-aware relative deflection per face. Recommended default for mixed-scale
         * assemblies (machine + small fasteners) - dramatically reduces triangle count and
         * meshing time with negligible visual difference. Set to false for absolute deflection
         * (the value of `meshPrecision` is then interpreted in model units).
         * @default true
         */
        meshRelative: boolean;
        /**
         * Add interior vertices for better curved face fidelity (slower, set false for speed).
         * @default false
         */
        internalVerticesMode: boolean;
        /**
         * Extra post-pass refining triangles that bulge beyond the deflection (slower, set
         * false for speed).
         * @default false
         */
        controlSurfaceDeflection: boolean;
    }
    /**
     * Options for converting STEP to glTF format with explicit Draco geometry
     * compression settings. Mirrors `ConvertStepToGltfDto` and exposes the Draco knobs
     * (8 trailing parameters of the underlying native function).
     */
    class ConvertStepToGltfWithDracoDto extends ConvertStepToGltfDto {
        constructor(stepData?: string | ArrayBuffer | Uint8Array | File | Blob);
        /**
         * Enable Draco geometry compression on output.
         * @default true
         */
        useDraco: boolean;
        /**
         * Draco compression level - 0 (fastest, largest) ... 10 (slowest, smallest).
         * @default 7
         * @minimum 0
         * @maximum 10
         * @step 1
         */
        dracoCompressionLevel: number;
        /**
         * Quantization bits for vertex positions.
         * @default 14
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizePositionBits: number;
        /**
         * Quantization bits for normals.
         * @default 10
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeNormalBits: number;
        /**
         * Quantization bits for texture coordinates (UVs).
         * @default 12
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeTexcoordBits: number;
        /**
         * Quantization bits for vertex colors.
         * @default 8
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeColorBits: number;
        /**
         * Quantization bits for generic attributes.
         * @default 12
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeGenericBits: number;
        /**
         * Apply a single quantization grid across all attributes.
         * @default false
         */
        dracoUnifiedQuantization: boolean;
    }
    /**
     * glTF node/mesh naming format options.
     * Controls how node and mesh names are generated in the output glTF.
     */
    enum gltfNameFormatEnum {
        /** Omit the name */
        empty = "empty",
        /** Use product name (shared by multiple instances) */
        product = "product",
        /** Use instance name */
        instance = "instance",
        /** Use instance name, fall back to product name */
        instanceOrProduct = "instanceOrProduct",
        /** Use product name, fall back to instance name */
        productOrInstance = "productOrInstance",
        /** Use both product and instance names "Product [Instance]" */
        productAndInstance = "productAndInstance",
        /** Verbose naming combining Product+Instance+OCAF (for debugging) */
        productAndInstanceAndOcaf = "productAndInstanceAndOcaf"
    }
    /**
     * glTF transformation format options.
     * Controls how node transformations are encoded in the output glTF.
     */
    enum gltfTransformFormatEnum {
        /** Compact format - uses TRS when possible, Mat4 otherwise */
        compact = "compact",
        /** Always use 4x4 matrix format */
        mat4 = "mat4",
        /** Always use Translation-Rotation-Scale format */
        trs = "trs"
    }
    /**
     * Advanced options for converting STEP to glTF format.
     * Provides full control over STEP reading, meshing, and glTF export options.
     * Use this for performance tuning - disable features you don't need.
     */
    class ConvertStepToGltfAdvancedDto {
        constructor(stepData?: string | ArrayBuffer | Uint8Array | File | Blob);
        /**
         * STEP data as string (for plain text files), ArrayBuffer, Uint8Array, File, or Blob.
         * Supports compressed .stpz files - gzip-compressed data is automatically decompressed.
         * @default undefined
         */
        stepData: string | ArrayBuffer | Uint8Array | File | Blob;
        /**
         * Read color attributes from STEP file.
         * Required for colored glTF output.
         * @default true
         */
        readColors: boolean;
        /**
         * Read name attributes from STEP file.
         * Disable for faster parsing if names are not needed.
         * @default true
         */
        readNames: boolean;
        /**
         * Read material attributes from STEP file.
         * Required for material properties in glTF.
         * @default true
         */
        readMaterials: boolean;
        /**
         * Read layer attributes from STEP file.
         * Usually not needed for glTF output.
         * @default false
         */
        readLayers: boolean;
        /**
         * Read validation properties from STEP file.
         * Usually not needed for glTF output.
         * @default false
         */
        readProps: boolean;
        /**
         * Mesh linear deflection (triangulation precision).
         * When `meshRelative` is true (default), this is a fraction of each edge's length
         * (e.g. 0.005 = 0.5%) so deflection auto-scales with feature size.
         * When `meshRelative` is false, this is absolute in model units (mm for STEP).
         * @default 0.005
         * @minimum 0.0001
         * @maximum 10
         * @step 0.001
         */
        meshDeflection: number;
        /**
         * Mesh angular deflection in radians.
         * Controls curvature-based refinement.
         * @default 0.5
         * @minimum 0.01
         * @maximum 3.14159
         * @step 0.1
         */
        meshAngle: number;
        /**
         * Enable parallel meshing for multi-threaded builds.
         * Recommended to keep enabled.
         * @default true
         */
        meshParallel: boolean;
        /**
         * Face count threshold for the legacy per-sub-shape meshing fallback.
         * Default -1 means single-pass meshing of the whole compound (fastest, recommended).
         * Set to a positive value (e.g. 100000) to fall back to per-solid meshing for
         * very large assemblies in memory-constrained environments.
         * @default -1
         * @minimum -1
         * @maximum 500000
         * @step 10000
         */
        faceCountThreshold: number;
        /**
         * Use size-aware relative deflection per face (recommended). When true,
         * `meshDeflection` is interpreted as a fraction of each edge's length.
         * Set to false to use absolute deflection in model units.
         * @default true
         */
        meshRelative: boolean;
        /**
         * Enable internal vertices mode for more accurate mesh on complex faces.
         * @default false
         */
        internalVerticesMode: boolean;
        /**
         * Enable control surface deflection for better quality on curved surfaces.
         * @default false
         */
        controlSurfaceDeflection: boolean;
        /**
         * Merge faces within a single part into one mesh.
         * Produces smaller file sizes.
         * @default true
         */
        mergeFaces: boolean;
        /**
         * Prefer 16-bit indices when merging faces.
         * Produces smaller binary data when mesh fits in 16-bit indices.
         * @default true
         */
        splitIndices16: boolean;
        /**
         * Enable parallel glTF writing.
         * Recommended for large files.
         * @default true
         */
        parallelWrite: boolean;
        /**
         * Embed textures in GLB output.
         * Only applies to binary (GLB) format.
         * @default true
         */
        embedTextures: boolean;
        /**
         * Export UV coordinates even without textures.
         * @default false
         */
        forceUVExport: boolean;
        /**
         * Node naming format in output glTF.
         * @default instance
         */
        nodeNameFormat: gltfNameFormatEnum;
        /**
         * Mesh naming format in output glTF.
         * @default instance
         */
        meshNameFormat: gltfNameFormatEnum;
        /**
         * Transformation format in output glTF.
         * @default compact
         */
        transformFormat: gltfTransformFormatEnum;
        /**
         * Convert Z-up (OCCT default) to Y-up (glTF standard).
         * Set to false to keep Z-up coordinate system.
         * @default true
         */
        adjustZtoY: boolean;
        /**
         * Scale factor for the model.
         * Useful for unit conversion (e.g., 0.001 to convert mm to meters).
         * Set to 1.0 for no scaling.
         * @default 1.0
         * @minimum 0.000001
         * @maximum 1000000
         * @step 0.001
         */
        scale: number;
    }
    /**
     * Advanced options for converting STEP to glTF format with explicit Draco
     * geometry compression settings. Mirrors `ConvertStepToGltfAdvancedDto` and
     * adds the 8 Draco knobs supported by the underlying native function.
     */
    class ConvertStepToGltfAdvancedWithDracoDto extends ConvertStepToGltfAdvancedDto {
        constructor(stepData?: string | ArrayBuffer | Uint8Array | File | Blob);
        /**
         * Enable Draco geometry compression on output.
         * @default true
         */
        useDraco: boolean;
        /**
         * Draco compression level - 0 (fastest, largest) ... 10 (slowest, smallest).
         * @default 7
         * @minimum 0
         * @maximum 10
         * @step 1
         */
        dracoCompressionLevel: number;
        /**
         * Quantization bits for vertex positions.
         * @default 14
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizePositionBits: number;
        /**
         * Quantization bits for normals.
         * @default 10
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeNormalBits: number;
        /**
         * Quantization bits for texture coordinates (UVs).
         * @default 12
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeTexcoordBits: number;
        /**
         * Quantization bits for vertex colors.
         * @default 8
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeColorBits: number;
        /**
         * Quantization bits for generic attributes.
         * @default 12
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeGenericBits: number;
        /**
         * Apply a single quantization grid across all attributes.
         * @default false
         */
        dracoUnifiedQuantization: boolean;
    }
    /**
     * DTO for building an assembly document.
     * Returns a document handle that the caller manages.
     * @typeParam T - Shape type (TopoDS_Shape or pointer)
     * @typeParam D - Document type (Handle_TDocStd_Document or pointer)
     */
    class BuildAssemblyDocumentDto<T, D> {
        constructor(structure?: Models.OCCT.AssemblyStructureDef<T>, existingDocument?: D, sourceDocuments?: D[]);
        /**
         * Assembly structure definition with parts and nodes
         * @default undefined
         */
        structure: Models.OCCT.AssemblyStructureDef<T>;
        /**
         * Optional existing document handle to reuse.
         * If provided and valid, the document will be cleared and updated instead of creating a new one.
         * This is useful for updating an assembly without creating a new document each time.
         * @default undefined
         * @optional true
         */
        existingDocument?: D;
        /**
         * Optional array of source document handles referenced by `structure.loadedParts` entries
         * via `sourceDocumentIndex`. Typically these are documents previously loaded with
         * loadStepToDoc. Lifetime of source documents is the caller's responsibility — they are
         * not modified or deleted by buildAssemblyDocument.
         * @default undefined
         * @optional true
         */
        sourceDocuments?: D[];
    }
    /**
     * DTO for creating a single assembly part definition.
     * Use this in visual programming to define a part that can be instanced.
     */
    class CreateAssemblyPartDto<T> {
        constructor(id?: string, shape?: T, name?: string, colorRgba?: Base.ColorRGBA);
        /**
         * Unique identifier for referencing this part in nodes
         * @default undefined
         */
        id: string;
        /**
         * The shape for this part
         * @default undefined
         */
        shape: T;
        /**
         * Display name for the part (appears in STEP file and viewers)
         * @default undefined
         */
        name: string;
        /**
         * Optional color for the part (RGBA, values 0-1)
         * @default {"r":0.5,"g":0.5,"b":0.5,"a":1}
         * @min 0
         * @max 1
         */
        colorRgba?: Base.ColorRGBA;
    }
    /**
     * DTO for creating an assembly node (container for other nodes).
     * Assembly nodes group instances and other assemblies together.
     */
    class CreateAssemblyNodeDto {
        constructor(id?: string, name?: string, parentId?: string, colorRgba?: Base.ColorRGBA);
        /**
         * Unique identifier for this assembly node
         * @default undefined
         */
        id: string;
        /**
         * Display name for the assembly
         * @default undefined
         */
        name: string;
        /**
         * Parent node ID. Leave undefined for root level assembly.
         * @default undefined
         */
        parentId?: string;
        /**
         * Optional color for the assembly
         * @default {"r":0.5,"g":0.5,"b":0.5,"a":1}
         * @min 0
         * @max 1
         */
        colorRgba?: Base.ColorRGBA;
    }
    /**
     * DTO for creating an instance node (reference to a part with transform).
     * Instance nodes place a part at a specific location with optional transform.
     */
    class CreateInstanceNodeDto {
        constructor(id?: string, partId?: string, name?: string, parentId?: string, translation?: Base.Point3, rotation?: Base.Vector3, scale?: number, colorRgba?: Base.ColorRGBA);
        /**
         * Unique identifier for this instance node
         * @default undefined
         */
        id: string;
        /**
         * ID of the part to instance (must match a part's id)
         * @default undefined
         */
        partId: string;
        /**
         * Display name for this instance
         * @default undefined
         */
        name: string;
        /**
         * Parent assembly node ID. Leave undefined for root level.
         * @default undefined
         */
        parentId?: string;
        /**
         * Translation as [x, y, z]
         * @default [0, 0, 0]
         */
        translation?: Base.Point3;
        /**
         * Rotation as [rx, ry, rz] in degrees (Euler ZYX order)
         * @default [0, 0, 0]
         */
        rotation?: Base.Vector3;
        /**
         * Uniform scale factor
         * @default 1.0
         */
        scale?: number;
        /**
         * Optional color override for this instance
         * @default undefined
         */
        colorRgba?: Base.ColorRGBA;
    }
    /**
     * DTO for creating a part update definition.
     * Part updates specify changes to apply to existing parts in a document.
     */
    class CreatePartUpdateDto<T> {
        constructor(label?: string, shape?: T, name?: string, colorRgba?: Base.ColorRGBA);
        /**
         * Label of the existing part to update (e.g., "0:1:1:1").
         * Obtain this from document queries like getDocumentParts.
         * @default undefined
         */
        label: string;
        /**
         * New shape to replace the existing shape.
         * If undefined, the shape is not changed.
         * @default undefined
         */
        shape?: T;
        /**
         * New name for the part.
         * If undefined, the name is not changed.
         * @default undefined
         */
        name?: string;
        /**
         * New color for the part.
         * If undefined, the color is not changed.
         * @default undefined
         */
        colorRgba?: Base.ColorRGBA;
    }
    /**
     * DTO for combining parts and nodes into an assembly structure.
     * Use this as the final step to create a complete structure definition.
     *
     * For updating existing documents:
     * - Use `removals` to specify labels to remove
     * - Use `partUpdates` to update existing parts (shape, name, color)
     */
    class CombineAssemblyStructureDto<T> {
        constructor(parts?: Models.OCCT.AssemblyPartDef<T>[], nodes?: Models.OCCT.AssemblyNodeDef[], removals?: string[], partUpdates?: Models.OCCT.AssemblyPartUpdateDef<T>[], clearDocument?: boolean, loadedParts?: Models.OCCT.AssemblyLoadedPartDef[]);
        /**
         * List of part definitions (shapes that can be instanced)
         * @default []
         */
        parts: Models.OCCT.AssemblyPartDef<T>[];
        /**
         * List of node definitions (assemblies and instances)
         * @default []
         */
        nodes: Models.OCCT.AssemblyNodeDef[];
        /**
         * Labels to remove from existing document.
         * Can be part labels, instance labels, or assembly labels.
         * Ignored when creating a new document (no existingDocument provided).
         * @default undefined
         */
        removals?: string[];
        /**
         * Updates to apply to existing parts in the document.
         * Each update can change the shape, name, and/or color of a part.
         * Ignored when creating a new document (no existingDocument provided).
         * @default undefined
         */
        partUpdates?: Models.OCCT.AssemblyPartUpdateDef<T>[];
        /**
         * Whether to clear the existing document before adding new content.
         * Only relevant when an existingDocument is provided to buildAssemblyDocument.
         *
         * - `true`: Clear all existing shapes, then add new parts/nodes (full rebuild)
         * - `false`: Keep existing shapes, apply removals/updates, add new parts/nodes (incremental)
         *
         * @default false
         */
        clearDocument: boolean;
        /**
         * Parts imported from other documents (e.g. STEP-loaded). Each entry references a
         * source document via `sourceDocumentIndex` (matching the order of `sourceDocuments`
         * on buildAssemblyDocument) and copies a label (or all free shapes) into this assembly,
         * preserving sub-assembly hierarchy, names and colors. Instance nodes can then reference
         * them by `partId` to place the imported assembly multiple times with different transforms.
         * @default undefined
         */
        loadedParts?: Models.OCCT.AssemblyLoadedPartDef[];
    }
    /**
     * DTO for creating an imported part definition.
     * Imported parts copy a label tree from a source document (typically STEP-loaded) into
     * the new assembly, preserving sub-assembly hierarchy. They become referenceable as a
     * single part (by id) from any instance node.
     */
    class CreateImportedPartDto {
        constructor(id?: string, sourceDocumentIndex?: number, sourceLabel?: string, name?: string, colorRgba?: Base.ColorRGBA);
        /**
         * Unique identifier for referencing this imported part from instance nodes (via partId).
         * @default undefined
         */
        id: string;
        /**
         * Index into the `sourceDocuments` array passed to buildAssemblyDocument.
         * @default 0
         */
        sourceDocumentIndex: number;
        /**
         * Optional OCAF entry string of the label to copy from the source document (e.g. "0:1:1:1").
         * If omitted, all free shapes of the source document are imported (wrapped in a new
         * assembly compound when there are multiple).
         * @default undefined
         */
        sourceLabel?: string;
        /**
         * Optional display name override applied to the imported root label.
         * @default undefined
         */
        name?: string;
        /**
         * Optional color override applied to the imported root label.
         * @default undefined
         */
        colorRgba?: Base.ColorRGBA;
    }
    /**
     * DTO for setting the color of a label in a document.
     * Takes the document handle directly instead of docId.
     */
    class SetDocLabelColorDto<T> {
        constructor(document?: T, label?: string, r?: number, g?: number, b?: number, a?: number);
        /**
         * Assembly document handle from buildAssemblyDocument or loadStepToDoc
         * @default undefined
         */
        document: T;
        /**
         * Label of the part/instance to color
         * @default undefined
         */
        label: string;
        /**
         * Red component (0.0 - 1.0)
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.01
         */
        r: number;
        /**
         * Green component (0.0 - 1.0)
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.01
         */
        g: number;
        /**
         * Blue component (0.0 - 1.0)
         * @default 0.5
         * @minimum 0
         * @maximum 1
         * @step 0.01
         */
        b: number;
        /**
         * Alpha component (0.0 - 1.0, 1.0 = opaque)
         * @default 1.0
         * @minimum 0
         * @maximum 1
         * @step 0.01
         */
        a: number;
    }
    /**
     * DTO for setting the name of a label in a document.
     * Takes the document handle directly instead of docId.
     */
    class SetDocLabelNameDto<T> {
        constructor(document?: T, label?: string, name?: string);
        /**
         * Assembly document handle from buildAssemblyDocument or loadStepToDoc
         * @default undefined
         */
        document: T;
        /**
         * Label to rename
         * @default undefined
         */
        label: string;
        /**
         * New name
         * @default Renamed
         */
        name: string;
    }
    /**
     * DTO for querying a document (e.g., get parts, hierarchy).
     * Takes the document handle directly.
     */
    class DocumentQueryDto<T> {
        constructor(document?: T);
        /**
         * Assembly document handle from buildAssemblyDocument or loadStepToDoc
         * @default undefined
         */
        document: T;
    }
    /**
     * DTO for querying a specific label in a document.
     * Takes the document handle directly.
     */
    class DocumentLabelQueryDto<T> {
        constructor(document?: T, label?: string);
        /**
         * Assembly document handle from buildAssemblyDocument or loadStepToDoc
         * @default undefined
         */
        document: T;
        /**
         * Label entry string (e.g., "0:1:1:1")
         * @default undefined
         */
        label: string;
    }
    /**
     * DTO for loading a STEP file and returning a document handle.
     */
    class LoadStepToDocDto {
        constructor(stepData?: string | ArrayBuffer | Uint8Array | File | Blob);
        /**
         * STEP file content.
         * Accepts string, ArrayBuffer, Uint8Array, File, or Blob.
         * Supports both regular STEP and gzip-compressed STEP-Z.
         * @default undefined
         */
        stepData: string | ArrayBuffer | Uint8Array | File | Blob;
    }
    /**
     * DTO for exporting an assembly document to STEP format.
     * Takes the document handle directly.
     */
    class ExportDocumentToStepDto<T> {
        constructor(document?: T, fileName?: string, author?: string, organization?: string, compress?: boolean, tryDownload?: boolean);
        /**
         * Assembly document handle from buildAssemblyDocument or loadStepToDoc
         * @default undefined
         */
        document: T;
        /**
         * File name for the STEP header and download
         * @default assembly.step
         */
        fileName: string;
        /**
         * Author name for the STEP header (optional)
         * @default Bitbybit user
         */
        author: string;
        /**
         * Organization name for the STEP header (optional)
         * @default Bitbybit
         */
        organization: string;
        /**
         * Whether to compress as STEP-Z (gzip)
         * @default false
         */
        compress: boolean;
        /**
         * Whether to trigger a file download in the browser
         * @default false
         */
        tryDownload: boolean;
    }
    /**
     * DTO for exporting an assembly document directly to glTF (GLB) format.
     * Takes the document handle directly.
     */
    class ExportDocumentToGltfDto<T> {
        constructor(document?: T, meshDeflection?: number, meshAngle?: number, mergeFaces?: boolean, forceUVExport?: boolean, fileName?: string, tryDownload?: boolean);
        /**
         * Assembly document handle from buildAssemblyDocument or loadStepToDoc
         * @default undefined
         */
        document: T;
        /**
         * Mesh precision for triangulation. Lower values = finer mesh.
         * @default 0.1
         */
        meshDeflection: number;
        /**
         * Angular deflection for meshing in radians. Lower values = smoother curves.
         * @default 0.5
         */
        meshAngle: number;
        /**
         * Add interior vertices for better curved face fidelity (slower, set false for speed).
         * @default false
         */
        internalVerticesMode: boolean;
        /**
         * Extra post-pass refining triangles that bulge beyond the deflection (slower,
         * set false for speed).
         * @default false
         */
        controlSurfaceDeflection: boolean;
        /**
         * Whether to merge faces with same material for optimization.
         * Set to false to preserve face boundaries.
         * @default false
         */
        mergeFaces: boolean;
        /**
         * Whether to export texture coordinates (UVs).
         * @default false
         */
        forceUVExport: boolean;
        /**
         * File name for download (optional, should end with .glb)
         * @default assembly.glb
         */
        fileName: string;
        /**
         * Whether to trigger a file download in the browser
         * @default false
         */
        tryDownload: boolean;
    }
    /**
     * DTO for exporting an assembly document directly to glTF (GLB) format with
     * explicit Draco geometry compression settings. Mirrors `ExportDocumentToGltfDto`
     * and exposes the 8 Draco knobs of the underlying native function.
     */
    class ExportDocumentToGltfWithDracoDto<T> extends ExportDocumentToGltfDto<T> {
        constructor(document?: T, meshDeflection?: number, meshAngle?: number, mergeFaces?: boolean, forceUVExport?: boolean, fileName?: string, tryDownload?: boolean);
        /**
         * Enable Draco geometry compression on output.
         * @default true
         */
        useDraco: boolean;
        /**
         * Draco compression level - 0 (fastest, largest) ... 10 (slowest, smallest).
         * @default 7
         * @minimum 0
         * @maximum 10
         * @step 1
         */
        dracoCompressionLevel: number;
        /**
         * Quantization bits for vertex positions.
         * @default 14
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizePositionBits: number;
        /**
         * Quantization bits for normals.
         * @default 10
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeNormalBits: number;
        /**
         * Quantization bits for texture coordinates (UVs).
         * @default 12
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeTexcoordBits: number;
        /**
         * Quantization bits for vertex colors.
         * @default 8
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeColorBits: number;
        /**
         * Quantization bits for generic attributes.
         * @default 12
         * @minimum 0
         * @maximum 31
         * @step 1
         */
        dracoQuantizeGenericBits: number;
        /**
         * Apply a single quantization grid across all attributes.
         * @default false
         */
        dracoUnifiedQuantization: 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 HelixWireDto {
        constructor(radius?: number, pitch?: number, height?: number, center?: Base.Point3, direction?: Base.Vector3, clockwise?: boolean, tolerance?: number);
        /**
         * Radius of the helix
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Height per complete turn (vertical distance per 360°)
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        pitch: number;
        /**
         * Total height of the helix
         * @default 5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Center of the helix
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the helix axis
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * If true, helix winds clockwise when viewed from above
         * @default false
         */
        clockwise: boolean;
        /**
         * Approximation tolerance
         * @default 0.0001
         * @minimum 0
         * @maximum Infinity
         * @step 0.0001
         */
        tolerance: number;
    }
    class HelixWireByTurnsDto {
        constructor(radius?: number, pitch?: number, numTurns?: number, center?: Base.Point3, direction?: Base.Vector3, clockwise?: boolean, tolerance?: number);
        /**
         * Radius of the helix
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Height per complete turn
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        pitch: number;
        /**
         * Number of complete turns
         * @default 5
         * @minimum 0
         * @maximum Infinity
         * @step 0.5
         */
        numTurns: number;
        /**
         * Center of the helix
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the helix axis
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * If true, helix winds clockwise when viewed from above
         * @default false
         */
        clockwise: boolean;
        /**
         * Approximation tolerance
         * @default 0.0001
         * @minimum 0
         * @maximum Infinity
         * @step 0.0001
         */
        tolerance: number;
    }
    class TaperedHelixWireDto {
        constructor(startRadius?: number, endRadius?: number, pitch?: number, height?: number, center?: Base.Point3, direction?: Base.Vector3, clockwise?: boolean, tolerance?: number);
        /**
         * Starting radius of the tapered helix
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        startRadius: number;
        /**
         * Ending radius of the tapered helix
         * @default 0.5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        endRadius: number;
        /**
         * Height per complete turn
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        pitch: number;
        /**
         * Total height of the helix
         * @default 5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        height: number;
        /**
         * Center of the helix
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Direction of the helix axis
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * If true, helix winds clockwise when viewed from above
         * @default false
         */
        clockwise: boolean;
        /**
         * Approximation tolerance
         * @default 0.0001
         * @minimum 0
         * @maximum Infinity
         * @step 0.0001
         */
        tolerance: number;
    }
    class FlatSpiralWireDto {
        constructor(startRadius?: number, endRadius?: number, numTurns?: number, center?: Base.Point3, direction?: Base.Vector3, clockwise?: boolean, tolerance?: number);
        /**
         * Starting radius from center
         * @default 0.5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        startRadius: number;
        /**
         * Ending radius from center
         * @default 5
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        endRadius: number;
        /**
         * Number of complete turns
         * @default 5
         * @minimum 0
         * @maximum Infinity
         * @step 0.5
         */
        numTurns: number;
        /**
         * Center of the spiral
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * Normal direction of the spiral plane
         * @default [0, 1, 0]
         */
        direction: Base.Vector3;
        /**
         * If true, spiral winds clockwise when viewed from above
         * @default false
         */
        clockwise: boolean;
        /**
         * Approximation tolerance
         * @default 0.0001
         * @minimum 0
         * @maximum Infinity
         * @step 0.0001
         */
        tolerance: number;
    }
    class TextWiresDto {
        constructor(text?: string, xOffset?: number, yOffset?: number, height?: number, lineSpacing?: number, letterSpacing?: number, align?: Base.horizontalAlignEnum, extrudeOffset?: number, origin?: Base.Point3, rotation?: number, direction?: Base.Vector3, centerOnOrigin?: boolean);
        /**
         * The text
         * @default Hello World
         */
        text?: string;
        /**
         * The x offset
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        xOffset?: number;
        /**
         * The y offset
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        yOffset?: number;
        /**
         * The height of the text
         * @default 1
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        height?: number;
        /**
         * The line spacing
         * @default 2
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        lineSpacing?: number;
        /**
         * The letter spacing offset
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        letterSpacing?: number;
        /**
         * The extrude offset
         * @default left
         */
        align?: Base.horizontalAlignEnum;
        /**
         * The extrude offset
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        extrudeOffset?: number;
        /**
         * Indicates whether to center text on origin
         * @default false
         */
        centerOnOrigin: boolean;
    }
    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;
    }
    class SimpleLinearLengthDimensionDto {
        constructor(start?: Base.Point3, end?: Base.Point3, direction?: Base.Vector3, offsetFromPoints?: number, crossingSize?: number, labelSuffix?: string, labelSize?: number, labelOffset?: number, labelRotation?: number, arrowType?: dimensionEndTypeEnum, arrowSize?: number, arrowAngle?: number, arrowsFlipped?: boolean, labelFlipHorizontal?: boolean, labelFlipVertical?: boolean, labelOverwrite?: string, removeTrailingZeros?: boolean);
        /**
         * The start point for dimension
         * @default undefined
         */
        start: Base.Point3;
        /**
         * The end point for dimension
         * @default undefined
         */
        end?: Base.Point3;
        /**
         * The dimension direction (must include length)
         * @default undefined
         */
        direction?: Base.Vector3;
        /**
         * The dimension label
         * @default 0
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        offsetFromPoints?: number;
        /**
         * The dimension crossing size
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        crossingSize?: number;
        /**
         * The dimension label decimal places
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        decimalPlaces?: number;
        /**
         * The dimension label suffix
         * @default (cm)
         */
        labelSuffix?: string;
        /**
         * The dimension label size
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        labelSize?: number;
        /**
         * The dimension label offset
         * @default 0.3
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        labelOffset?: number;
        /**
         * The dimension label rotation
         * @default 0
         * @minimum -360
         * @maximum 360
         * @step 1
         */
        labelRotation?: number;
        /**
         * End type for dimension
         * @default none
         */
        endType?: dimensionEndTypeEnum;
        /**
         * The size/length of dimension arrows
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        arrowSize?: number;
        /**
         * The total angle between arrow lines (max 90 degrees)
         * @default 30
         * @minimum 0
         * @maximum 90
         * @step 1
         */
        arrowAngle?: number;
        /**
         * Flip arrows to point outward instead of inward
         * @default false
         */
        arrowsFlipped?: boolean;
        /**
         * Flip label horizontally
         * @default false
         */
        labelFlipHorizontal?: boolean;
        /**
         * Flip label vertically
         * @default false
         */
        labelFlipVertical?: boolean;
        /**
         * Override label text with custom expression (supports 'val' for computed value, e.g., '100*val', 'Length: val mm')
         * @default 1*val
         * @optional true
         */
        labelOverwrite?: string;
        /**
         * Remove trailing zeros from decimal places
         * @default false
         */
        removeTrailingZeros?: boolean;
    }
    class SimpleAngularDimensionDto {
        constructor(direction1?: Base.Point3, direction2?: Base.Point3, center?: Base.Point3, radius?: number, offsetFromCenter?: number, crossingSize?: number, radians?: boolean, labelSuffix?: string, labelSize?: number, labelOffset?: number, endType?: dimensionEndTypeEnum, arrowSize?: number, arrowAngle?: number, arrowsFlipped?: boolean, labelRotation?: number, labelFlipHorizontal?: boolean, labelFlipVertical?: boolean, labelOverwrite?: string, removeTrailingZeros?: boolean);
        /**
         * The first direction for dimension
         * @default [1, 0, 0]
         */
        direction1: Base.Point3;
        /**
         * The second direction for dimension
         * @default [0, 0, 1]
         */
        direction2: Base.Point3;
        /**
         * The center point for dimension
         * @default [0, 0, 0]
         */
        center: Base.Point3;
        /**
         * The dimension radius
         * @default 4
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        radius: number;
        /**
         * Offset from center
         * @default 0.5
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        offsetFromCenter: number;
        /**
         * The dimension crossing size
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extraSize: number;
        /**
         * The dimension label decimal places
         * @default 2
         * @minimum 0
         * @maximum Infinity
         * @step 1
         */
        decimalPlaces: number;
        /**
         * The dimension label suffix
         * @default (deg)
         */
        labelSuffix: string;
        /**
         * The dimension label size
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        labelSize: number;
        /**
         * The dimension label offset
         * @default 0.3
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        labelOffset: number;
        /**
         * If true the angle is in radians
         * @default false
         */
        radians: boolean;
        /**
         * End type for dimension
         * @default none
         */
        endType?: dimensionEndTypeEnum;
        /**
         * The size/length of dimension arrows
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        arrowSize?: number;
        /**
         * The total angle between arrow lines (max 90 degrees)
         * @default 30
         * @minimum 0
         * @maximum 90
         * @step 1
         */
        arrowAngle?: number;
        /**
         * Flip arrows to point outward instead of inward
         * @default false
         */
        arrowsFlipped?: boolean;
        /**
         * Additional rotation angle for the label in degrees
         * @default 0
         * @minimum -360
         * @maximum 360
         * @step 1
         */
        labelRotation?: number;
        /**
         * Flip label horizontally
         * @default false
         */
        labelFlipHorizontal?: boolean;
        /**
         * Flip label vertically
         * @default false
         */
        labelFlipVertical?: boolean;
        /**
         * Override label text with custom expression (supports 'val' for computed value, e.g., '100*val', 'Angle: val deg')
         * @default 1*val
         * @optional true
         */
        labelOverwrite?: string;
        /**
         * Remove trailing zeros from decimal places
         * @default false
         */
        removeTrailingZeros?: boolean;
    }
    class PinWithLabelDto {
        constructor(startPoint?: Base.Point3, endPoint?: Base.Point3, direction?: Base.Vector3, offsetFromStart?: number, label?: string, labelOffset?: number, labelSize?: number, endType?: dimensionEndTypeEnum, arrowSize?: number, arrowAngle?: number, arrowsFlipped?: boolean, labelRotation?: number, labelFlipHorizontal?: boolean, labelFlipVertical?: boolean);
        /**
         * The start point for dimension
         * @default [0, 0, 0]
         */
        startPoint: Base.Point3;
        /**
         * The end point for dimension
         * @default [0, 5, 2]
         */
        endPoint?: Base.Point3;
        /**
         * The dimension direction (must include length)
         * @default [0, 0, 1]
         */
        direction?: Base.Vector3;
        /**
         * Offset from the start point
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        offsetFromStart?: number;
        /**
         * The dimension label
         * @default Pin
         */
        label?: string;
        /**
         * The dimension label offset
         * @default 0.3
         * @minimum -Infinity
         * @maximum Infinity
         * @step 0.1
         */
        labelOffset?: number;
        /**
         * The dimension label size
         * @default 0.1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        labelSize?: number;
        /**
         * End type for dimension
         * @default none
         */
        endType?: dimensionEndTypeEnum;
        /**
         * The size/length of dimension arrows
         * @default 0.3
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        arrowSize?: number;
        /**
         * The total angle between arrow lines (max 90 degrees)
         * @default 30
         * @minimum 0
         * @maximum 90
         * @step 1
         */
        arrowAngle?: number;
        /**
         * Flip arrows to point outward instead of inward
         * @default false
         */
        arrowsFlipped?: boolean;
        /**
         * Additional rotation angle for the label in degrees
         * @default 0
         * @minimum -360
         * @maximum 360
         * @step 1
         */
        labelRotation?: number;
        /**
         * Flip label horizontally
         * @default false
         */
        labelFlipHorizontal?: boolean;
        /**
         * Flip label vertically
         * @default false
         */
        labelFlipVertical?: boolean;
    }
    class StarSolidDto extends StarDto {
        constructor(outerRadius?: number, innerRadius?: number, numRays?: number, center?: Base.Point3, direction?: Base.Vector3, offsetOuterEdges?: number, half?: boolean, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class NGonSolidDto extends NGonWireDto {
        constructor(center?: Base.Point3, direction?: Base.Vector3, nrCorners?: number, radius?: number, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class ParallelogramSolidDto extends ParallelogramDto {
        constructor(center?: Base.Point3, direction?: Base.Vector3, aroundCenter?: boolean, width?: number, height?: number, angle?: number, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class HeartSolidDto extends Heart2DDto {
        constructor(center?: Base.Point3, direction?: Base.Vector3, rotation?: number, sizeApprox?: number, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class ChristmasTreeSolidDto extends ChristmasTreeDto {
        constructor(height?: number, innerDist?: number, outerDist?: number, nrSkirts?: number, trunkHeight?: number, trunkWidth?: number, half?: boolean, rotation?: number, origin?: Base.Point3, direction?: Base.Vector3, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
    class LPolygonSolidDto extends LPolygonDto {
        constructor(widthFirst?: number, lengthFirst?: number, widthSecond?: number, lengthSecond?: number, align?: directionEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3, extrusionLengthFront?: number, extrusionLengthBack?: number);
        /**
         * Extrusion length in the forward direction
         * @default 1
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthFront: number;
        /**
         * Extrusion length in the backward direction
         * @default 0
         * @minimum 0
         * @maximum Infinity
         * @step 0.1
         */
        extrusionLengthBack: number;
    }
}