archiyou 0.7.0

package/dist/src/Shape.d.ts

@@ -0,0 +1,628 @@
+import { toSVGOptions, PointLike, PointLikeOrAnyShape, AnyShape, Pivot, MainAxis, AnyShapeCollection, AnyShapeOrCollection, PointLikeOrAnyShapeOrCollection, AnyShapeOrCollectionOrSelectionString, LinearShape, ShapeType, Side, SideZ, CoordArray, ShapeClone, Link, SelectorPointRange, SelectorAxisCoord, SelectorBbox, SelectorIndex, ShapeAttributes, ObjStyle, MeshShape, FaceMesh, EdgeMesh, VertexMesh, MeshCache, Annotation, DimensionOptions, DimensionLine, BeamLikeDims, Alignment, OrientationXY, MeshingQualitySettings, Obj, Vector, Point, Bbox, OBbox, Vertex, Edge, Wire, Face, Shell, Solid, ShapeCollection, Brep } from './internal';
+type IVertex = Vertex;
+type IEdge = Edge;
+type ISolid = Solid;
+type IWire = Wire;
+type IDimensionLine = DimensionLine;
+export declare class Shape {
+    _oc: any;
+    _brep: Brep;
+    _obj: Obj;
+    _parent: AnyShapeOrCollection;
+    _ocShape: any;
+    _ocId: string;
+    _isTmp: boolean;
+    _cloned: ShapeClone | null;
+    _meshCache: MeshCache;
+    attributes: ShapeAttributes;
+    annotations: Array<Annotation>;
+    CLASSNAME_TO_SHAPE_ENUM_STATIC: {
+        [key: string]: string;
+    };
+    CLASSNAME_TO_SHAPE_ENUM: {
+        [key: string]: any;
+    };
+    OC_SHAPE_ENUM_TO_CLASSNAME: {
+        [key: string]: string;
+    };
+    constructor();
+    /** Make Shape from OC Shape */
+    _fromOcShape(ocShape?: any): AnyShapeOrCollection;
+    /** Update _OcShape from Shape properties */
+    _updateOcShape(): void;
+    /** Update properties from current OC Shape */
+    _updateFromOcShape(ocShape?: any): void;
+    /** Manually clear existing OC Shape */
+    _clearOcShape(): void;
+    /** Do an effort to create a Shape */
+    fromAll(value: any): AnyShape;
+    /** Class method for ease of use */
+    static fromAll(value: any): AnyShape;
+    attribute(key?: string, value?: any): any | AnyShape;
+    /** Alias for attribute() */
+    attr(key?: string, value?: any): any | AnyShape;
+    /** Get attributes of Shape */
+    attrs(): ShapeAttributes;
+    /** Copy attributes from other Shape */
+    _copyAttributes(from: Shape): void;
+    getCursor(): void;
+    /** Check and fix Shape after operation: can get overloaded in subclasses */
+    checkAndFix(): AnyShape;
+    /** Unify Shapes that are lying on the same plane and can be combined */
+    _unifyDomain(): AnyShape;
+    /** For now we don't have a sense of a pivot and thus clear position of an object, we calculate its center
+        We can override this in the individual subclasses.
+        TODO: For example an position of a Wire is probably more intuitive as its start Vertex
+    */
+    position(): Point;
+    /** Attach obj to Shape for adding it to the scene and styling */
+    object(forceNew?: boolean): Obj;
+    /** Set color on the Object of this Shape */
+    color(value: string | number): this;
+    /** Set dashed lines on the Object of this Shape */
+    dashed(): this;
+    /** Set stroke width of lines of Shape */
+    lineWidth(n: number): this;
+    /** Get the color of this Shape as defined in its Obj container */
+    getColor(): number;
+    _getColorRGBA(): [number, number, number, number];
+    /** check if Shape is co-planar and return the normal of the workingplane if so! */
+    workPlaneNormal(): Vector;
+    /**
+     *   Some operations on Shape actually create new Shape types: For example Shape.intersections(other)
+     *   To Updating those in place we use the Obj container of the Shape
+     *   IMPORTANT: This is still confusing because existing references in script scope are not updated!!
+     */
+    replaceShape(newShapes: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** We can delete a Shape from the Scene by removing it's Obj container */
+    removeFromScene(): void;
+    isEmpty(): boolean;
+    _setShapeEnumToClassName(): void;
+    /** Convert Shape to Wire (private) */
+    _toWire(): IWire;
+    /** Try to convert the current Shape to a Wire */
+    toWire(): IWire;
+    /**  To have consistent API between Shape and ShapeCollection instances */
+    isShape(obj: any): boolean;
+    /**  To have consistent API between Shape and ShapeCollection instances */
+    isShapeCollection(): boolean;
+    static isShape(obj: any): any;
+    /** Create hash for this Shape: can be used to check if an Shape is the same instance (NOTE: not that is has equal geometry!) */
+    _hashcode(): string;
+    ocGeom(): any;
+    type(): ShapeType;
+    _getShapeTypeFromOcShape(ocShape: any): string;
+    /** Returns subType of current Shape: For example Edge::Line */
+    subType(): string;
+    /** If Shape is beam-like */
+    beamLike(): boolean;
+    beamDims(): BeamLikeDims;
+    /** is this Shape 2D */
+    is2D(): boolean;
+    /** is this Shape 2D on XY plane (used for SVG export for example) */
+    is2DXY(): boolean;
+    is3D(): boolean;
+    /** Test if a Shape is valid
+     *  NOTE: Since we have garbage collection on the OC Shape a Shape can become invalid
+     *  bacause for some reason the ocShape is deleted, giving a BindingError just using the Shape
+     *  So use this method when these errors pop up
+    */
+    valid(ocShape?: any): any;
+    /** For compatibility with ShapeCollection */
+    count(): number;
+    /** Length of a Shape (depending on specific class) */
+    length(): number;
+    /** The top surface area of Shape - for example the area of a Box is the top part */
+    area(): number;
+    /** The total surface Area of a Shape - for example the total surface area of Sphere is 4πr2 */
+    surface(): number;
+    /** Calculate the volume of this Shape */
+    volume(): number;
+    /** Get all Vertices of this Shape */
+    vertices(): AnyShapeCollection;
+    /** Get all Edges of this Shape */
+    edges(): AnyShapeCollection;
+    /** Get all Wires of this Shape */
+    wires(): AnyShapeCollection;
+    /** Get all Faces of this Shape */
+    faces(): AnyShapeCollection;
+    /** Get all Shells of this Shape */
+    shells(): AnyShapeCollection;
+    /** Get all Solids of this Shape */
+    solids(): AnyShapeCollection;
+    /** Calculate and set Bounding Box of Shape  */
+    bbox(withAnnotations?: boolean): Bbox;
+    /** Calculate Orientated Bounding Box of Shape */
+    obbox(): OBbox | null;
+    /** Calculate center of this Shape */
+    center(): Point;
+    /** Get max Point coordinate of Bbox of this Shape */
+    max(): Point;
+    /** Get min Point of Bbox of this Shape */
+    min(): Point;
+    /** Round geometry to globally set (in OC) tolerance */
+    round(): Shape;
+    /** Copy the Shape and add it to the Scene (private) */
+    _copy(): this;
+    /** Copy the Shape and add it to the Scene */
+    copy(addToScene?: boolean): this;
+    /** Return clone of this Shape */
+    clone(): AnyShape;
+    isClone(): boolean;
+    /** Remove cloning properties */
+    cancelCloning(): void;
+    clonedFrom(): AnyShape;
+    /** Move Shape to a position by offsetting all Geometry with a Vector */
+    move(vector: PointLike, ...args: any[]): this;
+    /** Aliass for move along x-direction */
+    moveX(distance: number): this;
+    /** Aliass for move along x-direction */
+    moveY(distance: number): this;
+    /** Aliass for move along x-direction */
+    moveZ(distance: number): this;
+    /** Move a copy of the Shape */
+    moved(v: PointLike, ...args: any[]): this;
+    /** Move Shape to a specific location using the pivot as center */
+    moveTo(to: PointLike, ...args: any[]): this;
+    /** Move Shape to specific x coordinate while keeping the other coords the same */
+    moveToX(x: number, pivot?: Alignment): this;
+    /** Move Shape to specific y coordinate while keeping the other coords the same */
+    moveToY(y: number, pivot?: Alignment): this;
+    /** Move Shape to specific z coordinate while keeping the other coords the same */
+    moveToZ(z: number, pivot?: Alignment): this;
+    /** Alias for moveToX/Y/Z() */
+    moveToAxisCoord(axis: MainAxis, coord: number): any;
+    /** Move copy of the Shape to a Point in space */
+    movedTo(to: PointLike, ...args: any[]): this;
+    /** Center Shape so that the center of the Shape is at the origin */
+    moveToOrigin(): this;
+    /** Resize Shape with a given factor
+        TODO: different scaling factors per axis? scale(0.5,1,2)
+    */
+    scale(factor?: number, pivot?: PointLike): this;
+    /** Same as scale but returning a copy of Shape */
+    _scaled(factor?: number, pivot?: PointLike): this;
+    scaled(factor?: number, pivot?: PointLike): this;
+    /**
+     *   Rotation around X,Y,Z axis with a given pivot (default: center)
+     *   NOTE: because the order of these rotations if very important we don't call it just rotate.
+     *   Use rotateX, rotateY and rotateZ to rotate around the main axis
+     */
+    rotateEuler(degX: number, degY?: number, degZ?: number, pivot?: Pivot): this;
+    /** Same as rotateEuler but makes a copy */
+    rotatedEuler(degX: number, degY: number, degZ: number, pivot: Pivot): this;
+    /**
+     *   Rotate sequencely around the x,y and z axis.
+     *   !!!! IMPORTANT: this is not the same as supplying the independant angles around the axis!
+     */
+    rotate(r: PointLike, ...args: any[]): this;
+    /** Rotate this Shape around the x-axis with a given angle and pivot (default: center) */
+    rotateX(deg: number, pivot?: Pivot): this;
+    /** Rotate this Shape around the y-axis with a given angle and pivot (default: center) */
+    rotateY(deg: number, pivot?: Pivot): this;
+    /** Rotate this Shape around the y-axis with a given angle and pivot (default: center) */
+    rotateZ(deg: number, pivot?: Pivot): this;
+    /** Rotates a Shape a given angle in degrees along a axis (default: Z) */
+    rotateAround(angle: number, axis?: PointLike, pivot?: Pivot): this;
+    /** Rotate Shape so that its orientated bounding box is aligned with the axes */
+    rotateToAxesOBbox(): this;
+    /** Rotate Shape to make normal of largest Face parallel to Z axis */
+    rotateToAlignLargestFaceToZ(): this;
+    /** Try to align Shape with x (horizontal) or y axis (vertical) as much as possible */
+    rotateToOrthoXY(o?: OrientationXY): this;
+    /** Rotate Shape to align as much as possible to axis
+        Alias for rotateToOrthoXY */
+    autoRotate(): this;
+    /** Rotate Shape to place flat on XY plane. Keeps x,y position */
+    rotateToLayFlat(o?: OrientationXY): this;
+    /** Alias for rotateToLayFlat
+     *  Rotates a Shape to lay flat on XY plane
+    */
+    layflat(): this;
+    fillet(radius?: number, at?: any): this;
+    chamfer(radius?: number, at?: any): this;
+    /** Check if a Solid Shape can be seen as a simple extrusion and return the base Face */
+    _extrudedFace(side?: SideZ): Face | null;
+    /** Flatten a Shape into a copy of a Face without altering the position
+     *  If given an axis we only select Faces that face that axis
+     *  Otherwise we consider the Shapes as extrusions and use extrudedFace
+    */
+    _flattened(axis?: MainAxis): AnyShape;
+    flattened(axis?: MainAxis): AnyShape;
+    /**
+     *   Move, rotate and (later) scale a Shape based on given points on the Shape and destination points
+     *   NOTE: you need two points for 2D alignment, 3 points for 3D alignment with rotation
+     *   TODO: Add scaling
+     */
+    alignByPoints(fromPoints: Array<Vector | Vertex | Point | Array<number> | string>, toPoints: Array<Vector | Vertex | Point | Array<number>>): this;
+    /** Same as alignByPoint but returns a copy and does not affect original */
+    alignedByPoints(fromPoints: Array<Vector | Vertex | Point | Array<number>>, toPoints: Array<Vector | Vertex | Point | Array<number>>): this;
+    /** Rotate this Shape by a Quaternion made by two Vectors */
+    rotateVecToVec(from: PointLike, to: PointLike, pivot?: PointLike): this;
+    /**
+     *   Mirror Shape
+     *   @param planeNormal The normal of the Mirror plane (not direction of orthogonal plane)
+     *   !!!! different from Vector.mirror()
+     *   origin: Origin of mirror plane
+     */
+    _mirrored(origin?: PointLike, normal?: PointLike): this;
+    mirrored(origin?: PointLike, normal?: PointLike): this;
+    /** Mirror Shape in X plane (x=0) with its center as pivot or given offset along x-axis */
+    mirrorX(offset?: number): this;
+    /** Create mirrored copy in X plane (x=0) with its center as pivot or given offset along x-axis */
+    _mirroredX(offset?: number): this;
+    mirroredX(offset?: number): this;
+    /** Mirror Shape in Y plane (y=0) with its center as pivot or given offset along y-axis */
+    mirrorY(offset?: number): this;
+    /** Create mirror copy of Shape in Y plane (y=0) with its center as pivot or given offset along y-axis */
+    _mirroredY(offset?: number): this;
+    mirroredY(offset?: number): this;
+    /** Mirror Shape in Z plane (z=0) with its center as pivot or given offset along z-axis */
+    mirrorZ(offset?: number): this;
+    /** Create mirror copy of Shape in Z plane (z=0) with its center as pivot or given offset along z-axis */
+    _mirroredZ(offset?: number): this;
+    /** Create mirrored copy relative to XY plane with its center as pivot and add to Scene */
+    mirroredZ(offset?: number): this;
+    extrude(amount?: number, direction?: PointLike): IEdge | Face | Shell | ISolid;
+    /**
+     *   Generic Shape extrude: basically meaning pulling a shape along a Vector for a distance to create a new Shape with higher dimensions
+     *   For example: Extrude a straight Line along a the z-axis to create a Rectangular Face
+     *   TODO: solid flag
+     */
+    _extruded(amount?: number, direction?: PointLike): IEdge | Face | Shell | Solid;
+    extruded(amount?: number, direction?: PointLike): IEdge | Face | Shell | Solid;
+    /** Extrude this Shape towards a given Point or other Shape - we do keep the normal of the Shape if available */
+    extrudedTo(other: PointLikeOrAnyShapeOrCollection, ...args: any[]): null | AnyShape;
+    /** Offset Shape to create a new version parallel to original with a given distance and by corners of given type (arc, intersection)  */
+    _offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): AnyShapeOrCollection;
+    /** Offset Shape to create a new version parallel to original with a given distance and by corners of given type (arc, intersection)  */
+    offset(amount?: number, type?: string, onPlaneNormal?: PointLike): AnyShapeOrCollection;
+    offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): AnyShapeOrCollection;
+    /** Thicken Shell or Solid to create a hollow Solid (private) */
+    _shelled(amount: number, excludeFaces?: AnyShapeOrCollectionOrSelectionString, type?: string): ISolid;
+    /** Thicken Face, Shell or Solid to create a hollow Solid (private) */
+    shelled(amount: number, excludeFaces?: AnyShapeOrCollectionOrSelectionString, type?: string): ISolid;
+    /** Same as shelled but with replacing the original */
+    shell(amount: number, excludeFaces?: AnyShapeOrCollectionOrSelectionString, type?: string): ISolid;
+    /** Thicken a Shape depending on its type
+   *  @param direction - all (grow from center), bottom, left, right, top
+   */
+    _thickened(amount: number, direction?: string): AnyShape;
+    /** Thicken a Shape depending on its type
+    *  @param direction - all (grow from center), bottom, left, right, top
+    */
+    thickened(amount: number, direction?: string): AnyShape;
+    thicken(amount: number, direction?: string): AnyShape;
+    /** Make a new Shape by revolving a non-solid Shape around an axis given by two Points (Private) */
+    _revolved(angle?: number, axisStart?: PointLike, axisEnd?: PointLike): AnyShapeOrCollection;
+    /** Make a new Shape by revolving a non-solid Shape around an axis given by two Points */
+    revolved(angle?: number, axisStart?: PointLike, axisEnd?: PointLike): AnyShapeOrCollection;
+    _lofted(sections: AnyShapeOrCollection, solid?: boolean): Shell | Solid;
+    lofted(sections: AnyShapeOrCollection, solid?: boolean): void;
+    loft(sections: AnyShapeOrCollection, solid?: boolean): Shell | Solid;
+    /** Create a new Shape by sweeping a the Shape's Wire representation through a Wire Path */
+    _sweeped(path: LinearShape, solid?: boolean, autoRotate?: boolean, alignToPath?: string): Face | Shell | Solid;
+    /** Sweep and add result to Scene */
+    sweeped(path: LinearShape, solid?: boolean, autoRotate?: boolean, alignToPath?: string): Face | Shell | Solid;
+    /** Is the same Shape in OC */
+    same(other: AnyShape): boolean;
+    /** Is exactly the same Shape based on its topology/geometry
+     *  TODO: Especially for complex Shapes this needs another look!
+     *  NOTE: Shape.equals() is the main method, no children override it!
+    */
+    equals(other: PointLikeOrAnyShape, tolerance?: number): boolean;
+    /** Calculate the distance between this Shape and other */
+    distance(other: PointLikeOrAnyShapeOrCollection, ...args: any[]): number;
+    /** Internal method that really calculates distance between two single Shapes */
+    _distanceToShape(other: AnyShape): number;
+    /** Calculate the closest distance between two Shapes: returns one or more straight Link Object, where start is from the first Shape
+    *      NOTE: If two Shapes are the same and parallel ( for example two Edges ) two links for each Vertex are returned
+   */
+    _closestLinks(other: PointLikeOrAnyShapeOrCollection): Array<Link>;
+    /** Returns a Link that is the shortest path from current Shape to the other  */
+    distanceLink(other: PointLikeOrAnyShapeOrCollection): Link;
+    /** Directly make a line from this Shape to the closest other */
+    lineTo(other: PointLikeOrAnyShapeOrCollection): Shape | null;
+    /** Returns the Vector of closest path from current Shape to the other */
+    distanceVec(other: PointLikeOrAnyShapeOrCollection): Vector;
+    distanceX(other: PointLikeOrAnyShapeOrCollection): number;
+    distanceY(other: PointLikeOrAnyShapeOrCollection): number;
+    distanceZ(other: PointLikeOrAnyShapeOrCollection): number;
+    _distanceAxis(other: PointLikeOrAnyShapeOrCollection, axis: MainAxis): number;
+    /** Get the shortest lines from Shape to the other */
+    links(other: PointLikeOrAnyShapeOrCollection): Array<Link>;
+    /** Get closest Point on the other Shape */
+    closest(other: PointLikeOrAnyShapeOrCollection): Point;
+    closestVertex(to: PointLike): IVertex;
+    _subtracted(others: AnyShapeOrCollection): AnyShapeOrCollection;
+    subtracted(others: AnyShapeOrCollection): AnyShapeOrCollection;
+    subtract(others: AnyShapeOrCollection, removeOthers?: boolean): AnyShapeOrCollection;
+    /** Cutting in OC with two Faces does not work
+     *  We hack a little by giving a slight height to the operants
+     */
+    _solidifyOperantFaces(others: AnyShapeCollection): AnyShapeCollection;
+    /** Unions one with another Shape(s) (Private method without adding to Scene) */
+    _unioned(other: AnyShapeOrCollection): AnyShapeOrCollection | null;
+    /** Unions one with another Shape */
+    unioned(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for unioned */
+    combined(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for unioned */
+    added(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for unioned */
+    fused(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for unioned */
+    merged(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Same as unioned but replacing current Shape in Obj */
+    union(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for union */
+    combine(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for union */
+    add(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for union */
+    merge(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Alias for union */
+    fuse(other: AnyShapeOrCollection): AnyShapeOrCollection;
+    /** Split current Shape into multiple ones using the given other Shapes (Private method: without adding to Scene)
+     *     The other Shapes are removed after the operation
+     */
+    _splitted(others: AnyShapeOrCollection, excludeOverlapping?: boolean): AnyShapeOrCollection;
+    /** Split current Shape into multiple ones using the given other Shapes */
+    splitted(others: AnyShapeOrCollection, excludeOverlapping?: boolean): AnyShapeOrCollection;
+    split(others: AnyShapeOrCollection, excludeOverlapping: boolean): AnyShapeOrCollection;
+    /** Limit a Shape by others: Always returns a single Shape of the same type
+     *   @param others - If not given we get all intersecting Shapes
+    */
+    capped(others?: AnyShapeOrCollection): AnyShape;
+    /** Cut off Shapes orthogonally by a plane with normal parallel to axis and at level and keep the largest piece
+    */
+    cutoff(axisNormal?: MainAxis, level?: number, smallest?: boolean): this;
+    /** Cut current Shape by other Shape and keep the biggest part */
+    cutoffBy(other: AnyShape, keepSmallest?: boolean): this;
+    /** Alias of cutoffBy */
+    trim(other: AnyShape, keepSmallest?: boolean): this;
+    _alignPerc(a?: Alignment): Array<number>;
+    /**
+     *  Align a given Shape to another by supplying a pivot for current Shape, another Shape and the alignment
+     *  For the pivot and alignment you can supply either a string with the combinations of sides (left,right,front,back,bottom,top)
+     *  or a array of percentage offsets to [left,front,bottom] corner or Shape
+     *  and for linear Shapes (Edge,Wire) also start and end !!!! TODO !!!!
+     */
+    align(other: AnyShape, pivot?: Pivot, alignment?: Alignment): this;
+    /** Alias for align */
+    alignTo(other: AnyShape, pivot?: Pivot, alignment?: Alignment): this;
+    /** Copy and then align */
+    aligned(other: AnyShape, pivot?: Pivot, alignment?: Alignment): this;
+    _alignStringToAlignPerc(alignment: Alignment): Array<number>;
+    /** Returns Point at percentage of Shape Bbox */
+    _pointAtPerc(uvw: PointLike): Point;
+    /** Get a Point at a specific alignment (topbottom, left etc) */
+    pointAtAlignment(alignment?: Alignment): Point;
+    intersects(other: PointLikeOrAnyShapeOrCollection): boolean;
+    /** Returns the shared Shape between two Shapes (private) */
+    _intersections(others: PointLikeOrAnyShapeOrCollection): AnyShapeCollection;
+    /** Returns the shared Shape between two Shapes */
+    intersections(others: PointLikeOrAnyShapeOrCollection): AnyShapeCollection;
+    intersection(others: PointLikeOrAnyShapeOrCollection): AnyShape;
+    _intersection(others: PointLikeOrAnyShapeOrCollection): AnyShape;
+    /** Return first Shape of intersections as copy */
+    intersected(others: PointLikeOrAnyShapeOrCollection): AnyShape;
+    /** Return first Shape of intersections and replace current Shape */
+    intersect(others: PointLikeOrAnyShapeOrCollection): AnyShape;
+    /** Calculate intersection with Section algorithm: This works for all Shape types but only returns Vertices or Edges */
+    _intersectionsSection(other: AnyShapeOrCollection): AnyShapeCollection;
+    /** Calculate intersection between Shapes ( from Face onward ) based on Common algoritm */
+    _intersectionsCommon(other: AnyShapeOrCollection): AnyShapeCollection;
+    /** Tests if two Shape overlap: meaning the two Shapes have at least on Vertex in common  */
+    overlaps(other: AnyShape): boolean;
+    /** Get amount of overlap [0-1] between this shape and given other */
+    overlapPerc(other: AnyShape): number;
+    /** Test if a one Shape completely contains the other.
+     *  If other is ShapeCollection test if all its Shapes are contained by current Shape
+     * */
+    contains(other: AnyShapeOrCollection): boolean;
+    /** Check if this Shape is parallel with the other - the specific meaning of this is different for each Shape Type */
+    parallel(other: any): boolean;
+    /** Get all Shapes in Scene that are intersecting with this Shape */
+    intersecting(): AnyShapeCollection;
+    overlapping(): AnyShapeCollection;
+    /** Cast a 'Ray' (infinite Line) towards the Shape and Link information ( the hit point and support topography: Vertex, Edge, Face) */
+    raycast(ray: IEdge): Link;
+    /**
+     *  Populate Shape (linear: Edge/Wire, planar: Face, Shell and solid) with Vertices
+     *  Resulting Vertices include start and end Vertices
+     */
+    populated(num?: number): AnyShapeCollection;
+    /** Copy current Shape a number of times along X,Y,Z axis with a given spacing */
+    array(sizes?: PointLike, offsets?: PointLike): AnyShapeCollection;
+    /** Copy Shape a number of times by spacing by a certain offset Vector  */
+    _array1D(size: number, offset: PointLike): AnyShapeCollection;
+    /** Alias for array along x-axis */
+    arrayX(size?: number, offset?: number): AnyShapeCollection;
+    /** Alias for array along y-axis */
+    arrayY(size?: number, offset?: number): AnyShapeCollection;
+    /** Alias for array along z-axis */
+    arrayZ(size?: number, offset?: number): AnyShapeCollection;
+    /** Copies a Shape along a linear path */
+    arrayAlong(path: IEdge | Wire, num: number, align?: boolean): ShapeCollection | this;
+    /** TODO: offer some forgiveness for treating a Shape like a ShapeCollection?
+     *      - filter
+     *      - first()
+    */
+    /** Get all geometries in this shape, you can specify the types (Vertex, Edge, Wire etc) */
+    _getEntities(type: ShapeType): AnyShapeCollection;
+    /** Get all subshapes of given type and those of lower types */
+    _getEntitiesDownFromType(type: ShapeType): AnyShapeCollection;
+    /** Returns type of Shape in Archiyou class name: Vertex, Edge, Wire, Face, Shell etc */
+    _shapeTypeEnumLookup(i: any): any;
+    /**
+     * Make specific from general Shape
+     * @param shape: oc.TopoDS_Shape
+     *
+     **/
+    _makeSpecificOcShape(ocShape: any, type?: string): any;
+    /** Sometimes we get a Shape instance - we can update that to the specific Shape class  */
+    specific(): AnyShape;
+    /** Sometimes we get a certain Shape with only one subshape:
+     *  like a Shell with only one Face,
+     *      - A Wire with only one Edge
+     *      - An Edge with only one Vertex
+     *   Then downgrade and return a new Shape
+     *  */
+    checkDowngrade(): AnyShape;
+    /** Get the Shapes that this Shape consists of
+     *
+     *  For example: Wire => [ Edge, Edge, Edge ]
+     *                Shell => [ Face, Face ]
+    */
+    getSubShapes(type: ShapeType): Array<Shape>;
+    /** Sometimes (for example in intersections) OCE returns a Compound Shape: Try to get real singular Shape */
+    _extractShapesFromOcCompound(ocShape: any): AnyShapeOrCollection;
+    _getOcShapesByType(ocShape: any, type?: string): Array<any>;
+    _shapeCollectionFromOcCompound(ocShapeCompound: any): ShapeCollection;
+    /** Check is a given string is a axis */
+    _checkAxis(axis: string): boolean;
+    /**
+     *   Select parts of this Shape
+     *
+     *   examples:
+     *       cube.select('Edges|Z')
+     *       cube.select('F>|front and F>|back) - multiple
+     *
+     */
+    select(selectString?: string): AnyShape | AnyShapeCollection;
+    _axisAndPlanesToVector(axis: string): Vector;
+    /** Selector: ParallelTo
+        @param to - string with axis name (X|Y|Z) or Array with coords [X,Y,Z]
+    */
+    _selectorParallelTo(shapes: AnyShapeCollection, to: MainAxis | CoordArray): AnyShapeCollection;
+    /** Selector: BiggestAlongAxis
+        Selects the Shape(s) that has the biggest coordinate along a certain axis - we use center and max
+        @param alongAxis: x,y or z or -x,-y,-z
+    */
+    _selectorDistanceAlongAxis(shapes: AnyShapeCollection, alongAxis: string): AnyShapeCollection;
+    _selectorOuterAlongAxis(shapes: AnyShapeCollection, alongAxis: MainAxis): AnyShapeCollection;
+    _selectorSmallestAlongAxis(shapes: AnyShapeCollection, alongAxis: MainAxis): AnyShapeCollection;
+    /** Selects all Shapes that have positive coordinates along given axis */
+    _selectorPositiveOnAxis(shapes: AnyShapeCollection, axis: MainAxis): AnyShapeCollection;
+    /** Selects all Shapes that have negative coordinates along given axis */
+    _selectorNegativeOnAxis(shapes: AnyShapeCollection, axis: MainAxis): AnyShapeCollection;
+    /** Selects shapes of a certain subtype  */
+    _selectorOfSubType(shapes: AnyShapeCollection, subType: string): AnyShapeCollection;
+    /** Sort and select Shapes based on distance to a Point - this method combines closest or furthest */
+    _selectorClosestOrFurtherstTo(shapes: AnyShapeCollection, to: PointLike, type?: string): AnyShapeCollection;
+    _selectorClosestTo(shapes: AnyShapeCollection, to: PointLike): AnyShapeCollection;
+    _selectorFurthestTo(shapes: AnyShapeCollection, to: PointLike): AnyShapeCollection;
+    _selectorWithinRange(shapes: AnyShapeCollection, pointRange: SelectorPointRange): AnyShapeCollection;
+    /** Selects Shapes that intersect with the sides of the Bbox
+     *  example: "V||fronttop"
+     *  TODO: Really make this more robust
+     */
+    _selectorSide(shapes: AnyShapeCollection, sidesString: string): AnyShapeCollection;
+    /** Select Shapes that have _all_ vertices at a specific coordinate within a certain tolerance
+        NOTE: we might introduce a selector later where we select Shapes that intersect a certain coordinate plane
+    */
+    _selectorAtAxisCoord(shapes: AnyShapeCollection, axisCoord: SelectorAxisCoord): AnyShapeCollection;
+    /** Select Shapes of which all the Vertices fit inside the given Bbox coordinates: We use Bbox.contains */
+    _selectorInBbox(shapes: AnyShapeCollection, bboxSelector: SelectorBbox): AnyShapeCollection;
+    /** Select SubShapes by index or indices */
+    _selectorIndex(shapes: AnyShapeCollection, index: SelectorIndex): AnyShapeCollection;
+    /** Sorts objects by distance in a certain axis (X,Y,Z) and direcion (- or +)
+     * @param axisAndDirection - string with axis, direction and count: X, -Z - TODO num (unique results)[2]
+     */
+    directionMinMaxSelector(shapes: AnyShapeCollection, axisAndDirection: string): AnyShape;
+    /** Get side subshapes - public version of _getSide */
+    side(sidesString?: string): AnyShapeCollection | null;
+    /** Getting Side sub shapes that overlap with side of bbox
+        New approach that ties Vertices/Edges/Faces to sides based on distance (and some tolerance)
+        
+        TODO: Visually it's evident that when a Face is touching a side, its subshapes (Edges,Vertices) need to be evaluated too!
+    */
+    _getSide(sidesString?: string): AnyShapeCollection | null;
+    /** Getting Side sub shapes that clearly overlaps Side of bbox
+     *  @param sideString combination of Sides. Example: 'lefttop'
+     *  Deprecated due to bad results
+    */
+    _getSideDeprecated(sidesString?: string): AnyShape | null;
+    dimension(dim?: DimensionOptions): IDimensionLine | Array<IDimensionLine>;
+    /** add dimension to annotations of this shape */
+    addAnnotations(a: Annotation | Array<Annotation>): boolean;
+    _updateAnnotations(): void;
+    autoDim(options?: DimensionOptions): void;
+    /** Adds current Shape by wrapping it into an object and adding it either to root Obj (=scene) or adding  */
+    addToScene(force?: boolean): Shape;
+    checkObj(): Obj;
+    _getObjStyle(): ObjStyle;
+    style(newStyle: ObjStyle): Shape;
+    /** NOTE: We don't use set/get here, because it doesnt play well with chaining */
+    name(n?: string): this | string;
+    /** Get name of container Obj */
+    setName(newName?: string): this;
+    /** Get name of container Obj */
+    getName(): string | undefined;
+    /** Get name of container Obj */
+    getId(): string;
+    hide(): this;
+    show(): this;
+    /** Return if the Shape Obj is set visible or not */
+    visible(): boolean;
+    /** Project this 3D Shape onto the XY Plane given by a normal Vector (up is the z-axis)
+     *  It groups the different Edge types in the returning Collection for easy extractions
+     *  Include flag all=true to include hidden Edges
+     *
+     *  IMPORTANT: Projection of a Solid that contains a certain Edge results in different alignment when projecting that Edge individually
+     *
+     *  TODO: find a way to identify edges/vertices from before and after projection
+     *          for example to preserve dimensions
+     *  */
+    _project(planeNormal?: PointLike, all?: boolean): AnyShapeCollection;
+    /** Project this 3D Shape onto the XY Plane given by a normal Vector (up is the z-axis)
+     *  It groups the different Edge types in the returning Collection for easy extractions */
+    project(planeNormal?: PointLike, all?: boolean): AnyShapeCollection;
+    /** Generate elevation from a given side without adding to Scene */
+    _elevation(side?: Side, all?: boolean): AnyShapeCollection;
+    /** Generate elevation from a given side and add to Scene */
+    elevation(side?: Side, all?: boolean): AnyShapeCollection;
+    /** Generate isometric view from Side or corner of ViewCube ('frontlefttop') or PointLike coordinate
+     *      Use showHidden=true to output with hidden lines
+     */
+    _isometry(viewpoint: string | PointLike, showHidden?: boolean, transferDimensions?: boolean): AnyShapeCollection;
+    /** Generate isometric view from Side or corner of ViewCube ('frontlefttop') or PointLike coordinate
+     *      Use showHidden=true to output with hidden lines
+     */
+    isometry(viewpoint?: string | PointLike, showHidden?: boolean): AnyShapeCollection;
+    /** Alias for isometry() */
+    iso(viewpoint?: string | PointLike, showHidden?: boolean): AnyShapeCollection;
+    /** Take Dimensions associated with current Shape to the projected 2D shape
+     *  NOTE: We can not yet associate dimensions with ShapeCollections,
+     *  so we link it to the specific Shape within this collection
+     */
+    _addDimensionsToProj(viewpoint: string | PointLike, projShapes: AnyShapeCollection): Array<DimensionLine>;
+    clearMeshCache(): void;
+    /** Output all Vertices of this Shape into an Array for further processing
+     *  NOTE: Because of its importance and size we do some extra efforts here to make sure we clear all memory
+    */
+    toMeshVertices(): Array<VertexMesh>;
+    toMeshEdges(quality: MeshingQualitySettings): Array<EdgeMesh>;
+    /** Do some sanity tests on original when this Shape is cloned */
+    _checkCloned(): boolean;
+    /** Output triangulated Mesh of Faces of this Shape */
+    toMeshFaces(quality: MeshingQualitySettings): Array<FaceMesh>;
+    /**
+     *  Exports OC data to verbose mesh data for Three JS.
+     *  To avoid clear seperation between AY Geom library and Three we output here raw data
+     *  There are interfaces defined in ExportModels.ts for clarity
+     */
+    toMeshShape(quality: MeshingQualitySettings): MeshShape;
+    /** Convenience method to save the shape to a file
+     *   the extension determines the file format
+     *   Supported formats: glb, svg, step, stl, dxf
+    */
+    save(filename: string, options?: any): void;
+    toData(): Object;
+    /** Output all properties of this Obj including that of its Shapes into a { key value } row. This is where Calc gets its main data from */
+    toTableData(): Object;
+    /** Export 2D Shape to SVG */
+    toSVG(options?: toSVGOptions): string;
+}
+export {};