archiyou 0.7.0

package/dist/src/ShapeCollection.d.ts

@@ -0,0 +1,429 @@
+import { PointLike, PointLikeOrAnyShapeOrCollection, ShapeType, AnyShape, AnyShapeOrSequence, AnyShapeOrCollection, AnyShapeCollection, MakeShapeCollectionInput, Pivot, AnyShapeSequence, Alignment, Bbox, Side, MeshingQualitySettings, LayoutOrderType, LayoutOptions, DimensionLevelSettings, AnnotationAutoDimStrategy, MeshShape, MeshShapeBuffer, Annotation, MainAxis, ObjStyle, toDXFOptions, toSVGOptions, Obj, Point, Shape, Wire, Brep } from './internal';
+export declare class ShapeCollection {
+    _oc: any;
+    _brep: Brep;
+    _obj: Obj;
+    _parent: AnyShapeOrCollection;
+    shapes: Array<AnyShape>;
+    _groups: {
+        [key: string]: Array<AnyShape>;
+    };
+    _packerModule: any;
+    annotations: Array<Annotation>;
+    constructor(entities?: MakeShapeCollectionInput, ...args: any[]);
+    /** Manually clear OC Shapes instances - used to make sure memory is released
+     *  NOTE: Please use automatic garbageCollection.targetOcForGarbageCollection() for more generic approach
+    */
+    _clearOcShapes(): void;
+    /** Try to convert anything to a ShapeCollection */
+    fromAll(entities?: MakeShapeCollectionInput): AnyShapeCollection;
+    /** Class method */
+    static fromAll(s: any, ...args: any[]): ShapeCollection;
+    /** Add entities (geometry and shapes) to Shape Collection */
+    _addEntities(entities?: MakeShapeCollectionInput, group?: string): AnyShapeCollection;
+    /** Add entities as named group */
+    addGroup(group?: string, entities?: MakeShapeCollectionInput): AnyShapeCollection;
+    _defineGroup(name: string, shapes?: ShapeCollection): any;
+    /** Get available groups in this ShapeCollection */
+    groups(): Array<string>;
+    /** Get shapes in group as ShapeCollection */
+    getGroup(name: string): ShapeCollection;
+    /** Alias for getGroup */
+    group(name: string): ShapeCollection;
+    /** Iterate over Shapes by group, ungrouped Shapes are grouped together
+     *    NOTE: for grouping within ShapeCollection see ShapeCollection addGroup()
+     *    This is not the same as the global group() function that makes a ShapeCollection
+    */
+    forEachGroup(func: (groupName: string, groupedShapes: ShapeCollection) => void): void;
+    /** EXPERIMENTAL: try to be compatible with Arrays by setting index keys on this instance */
+    _setFakeArrayKeys(): void;
+    /** EXPERIMENTAL: Set references to Shapes by name directly on instance */
+    _setFakeNameKeys(): void;
+    /** EXPERIMENTAL: directly access groups by adding property to instance
+     *   TODO: Check for overwriting properties!
+    */
+    _setFakeGroupKeys(): void;
+    /** Export to OC ListOfStype, used for Splitter algoritm */
+    _toOcListOfShape(): any;
+    toOcShapes(): Array<any>;
+    /** Combine all children Shapes into one Compund Shape (for export) */
+    toOcCompound(): any;
+    getShapes(): Array<AnyShape>;
+    /** Array API - for consitent API with Array */
+    get length(): number;
+    /** Array API - For consistency with Array */
+    concat(other: AnyShapeSequence): AnyShapeCollection;
+    /** Array API - For consistency with Array */
+    map(mapFunc: (element: AnyShape, index?: number, array?: Array<AnyShape>) => AnyShape): AnyShapeCollection;
+    /** Array API  */
+    every(checkFunc: (element: AnyShape, index?: number, array?: Array<AnyShape>) => boolean): boolean;
+    /** Place this ShapeCollection (and all it's child Shapes) into the Obj container */
+    setObj(obj: Obj): void;
+    /** Add Shape to ShapeCollection */
+    add(shapes?: AnyShapeOrSequence, ...args: any[]): this;
+    /**  Array API - Add Shape to ShapeCollection*/
+    push(shape: AnyShape): ShapeCollection;
+    /** Add Shape to ShapeCollection but not if it is already in it */
+    addUnique(shapes?: ShapeCollection, ...args: any[]): this;
+    /** Remove Shapes from ShapeCollection */
+    remove(shapes: AnyShapeOrCollection, ...args: any[]): ShapeCollection;
+    /** Clear current ShapeCollection */
+    empty(): this;
+    /** Return a new Collection of given Shapes removed */
+    removed(shapes: AnyShapeOrCollection): ShapeCollection;
+    /** Add Shape at beginning of collection */
+    prepend(shape: AnyShape): ShapeCollection;
+    /** Add Shape at beginning of collection */
+    prepended(shape: AnyShape): ShapeCollection;
+    /** Add Shape to right of current ShapeCollection */
+    addAligned(shape: AnyShape): this;
+    replace(shapes: AnyShapeOrCollection, newShapes: AnyShapeOrCollection): ShapeCollection;
+    /** Set attribute to all shapes */
+    attribute(key: string, value: any): AnyShapeCollection;
+    /** Shape API - move all Shapes in ShapeCollection */
+    move(vector: PointLike, ...args: any[]): AnyShapeCollection;
+    /** Shape API - move a copy of all Shapes in ShapeCollection */
+    moved(vector: PointLike, ...args: any[]): AnyShapeCollection;
+    /**  Shape API - Move center of Collection to a given point */
+    moveTo(to: PointLike, ...args: any[]): AnyShapeCollection;
+    /** Center Shape so that the center of the Shape is at the origin */
+    moveToOrigin(): AnyShapeCollection;
+    /** 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 shapes to given x coordinate */
+    moveToX(x: number): this;
+    /** Move shapes to given x coordinate */
+    moveToY(y: number): this;
+    /** Move shapes to given x coordinate */
+    moveToZ(z: number): this;
+    /** Shape API */
+    rotateEuler(degX?: number, degY?: number, degZ?: number, pivot?: PointLike): AnyShapeCollection;
+    /** Shape API */
+    rotatedEuler(degX?: number, degY?: number, degZ?: number, pivot?: PointLike): AnyShapeCollection;
+    /** Shape API - Rotate all Shapes around their centers with a given x,y,z angles */
+    rotate(r: PointLike, ...args: any[]): AnyShapeCollection;
+    /** Shape API - Rotate all Shapes around the x-axis with a given angle and given pivot (default: center) */
+    rotateX(deg: number, pivot?: Pivot): AnyShapeCollection;
+    /** Shape API - Rotate all Shapes around the y-axis with a given angle and given pivot (default: center) */
+    rotateY(deg: number, pivot?: Pivot): AnyShapeCollection;
+    /** Shape API - Rotate all Shapes around the z-axis with a given angle and given pivot (default: center of ShapeCollection) */
+    rotateZ(deg: number, pivot?: Pivot): AnyShapeCollection;
+    /** Shape API - Rotate all Shapes around a specific axis with a given angle (default: [0,0,1]) and given pivot (default: center) */
+    rotateAround(angle: number, axis?: PointLike, pivot?: Pivot): AnyShapeCollection;
+    /** Scale entire ShapeCollection */
+    scale(factor?: number, pivot?: PointLike): AnyShapeCollection;
+    /** Scale entire ShapeCollection and return copy */
+    scaled(factor?: number, pivot?: PointLike): AnyShapeCollection;
+    /** Shape API - Align Shapecollection to other Shape or ShapeCollection */
+    align(other: AnyShapeOrCollection, pivot?: Pivot, alignment?: Alignment): AnyShapeOrCollection;
+    /** Shape API - */
+    alignByPoints(...args: any[]): AnyShapeCollection;
+    /** Shape API - */
+    alignedByPoints(...args: any[]): AnyShapeCollection;
+    /** Shape API - */
+    rotateVecToVec(...args: any[]): AnyShapeCollection;
+    /** Shape API - Make an geometric array by offset ShapeCollection */
+    array(size: number | Array<number>, spacings: number | Array<number>): AnyShapeCollection;
+    /** Shape API */
+    _array1D(size: number, spacingOffset: PointLike): AnyShapeCollection;
+    /** Shape API - Mirror Shapes in ShapeCollection with mirror plane defined by planeNormal and origin */
+    mirrored(origin: PointLike, planeNormal: PointLike): AnyShapeCollection;
+    /** Shape API - Mirror Shapes relative to X-plane (x=0) with its collection center as pivot or given offset x-coord */
+    mirrorX(offset?: number): AnyShapeCollection;
+    /** Shape API - Mirror copies of Shapes relative to X-plane (x=0) with its collection center as pivot or given offset x-coord */
+    _mirroredX(offset?: number): ShapeCollection;
+    /** Shape API - Mirror copies of Shapes relative to X-plane (x=0) with its collection center as pivot or given offset x-coord */
+    mirroredX(offset?: number): ShapeCollection;
+    /** Shape API - Mirror Shapes relative to Y plane (y=0) with its collection center as pivot or given offset y-coord */
+    mirrorY(offset?: number): AnyShapeCollection;
+    /** Shape API - Mirror copies of Shapes relative to Y plane (y=0) with its collection center as pivot or given offset y-coord */
+    _mirroredY(offset?: number): ShapeCollection;
+    /** Shape API - Mirror copies of Shapes relative to Y plane (y=0) with its collection center as pivot or given offset y-coord */
+    mirroredY(offset?: number): ShapeCollection;
+    /** Shape API - Mirror Shapes relative to Z plane (z=0) with its collection center as pivot or given offset z-coord */
+    mirrorZ(offset?: number): AnyShapeCollection;
+    /** Shape API - Mirror copies of Shapes in Z-plane (z=0) with its collection center as pivot or given offset z-coord */
+    _mirroredZ(offset?: number): ShapeCollection;
+    /** Shape API - Mirror copies of Shapes relative to XZ plane with its collection center as pivot or given offset z-coord */
+    mirroredZ(offset?: number): ShapeCollection;
+    /** Shape API - offset Shapes in Collection */
+    offset(amount?: number, type?: string, onPlaneNormal?: PointLike): AnyShapeCollection;
+    /** Shape API - create copeis and offset Shapes in Collection  */
+    offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): AnyShapeCollection;
+    /** Shape API - Extrude Shapes in ShapeCollection a certain amount in a given direction (default: [0,0,1]) */
+    extrude(amount?: number, direction?: PointLike): AnyShapeCollection;
+    /** Shape API - Extrude Shapes in ShapeCollection a certain amount in a given direction (default: [0,0,1]) */
+    extruded(amount?: number, direction?: PointLike): AnyShapeCollection;
+    thicken(amount: number, direction?: string): ShapeCollection;
+    /** Create a new ShapeCollection with thickened Shapes */
+    thickened(amount: number, direction?: string): ShapeCollection;
+    /** Just a simple forwarder fillet */
+    fillet(radius: number, at?: any): ShapeCollection;
+    /** Shape API: Copy entire ShapeCollection and its Shapes and return a new one */
+    _copy(): ShapeCollection;
+    /** Shape API: Copy entire ShapeCollection and its Shapes and return a new one (add to Scene) */
+    copy(): ShapeCollection;
+    /** Make new ShapeCollection without copying the Shapes */
+    shallowCopy(): ShapeCollection;
+    clone(): ShapeCollection;
+    /** Shape API */
+    type(): string;
+    /** Shape API */
+    isShape(): boolean;
+    /** Shape/ShapeCollection API consistency */
+    isShapeCollection(): boolean;
+    static isShapeCollection(obj: any): boolean;
+    /** Shape API */
+    center(): Point;
+    /** Check if all Shapes in this collection are 2D and on the same plane */
+    is2D(): boolean;
+    is3D(): boolean;
+    /** Shape API - get combined bbox of all Shapes in Collection */
+    bbox(withAnnotations?: boolean): Bbox | null;
+    /** Shape API: get combined Shape area */
+    area(): number;
+    /** Shape API: get combined Shape volume */
+    volume(): number;
+    /** Shape API */
+    _hashcode(): string;
+    /** Shape API */
+    _intersections(others: PointLikeOrAnyShapeOrCollection): ShapeCollection;
+    /** Create intersecting Shapes between Shapes in this collection and other Shape or Collection */
+    intersections(others: PointLikeOrAnyShapeOrCollection): ShapeCollection;
+    /** Get Shapes that intersect with given Shape(s) */
+    intersecting(other: PointLikeOrAnyShapeOrCollection): ShapeCollection;
+    /** Alias for intersecting */
+    intersectors(other: PointLikeOrAnyShapeOrCollection): ShapeCollection;
+    /** Shape API */
+    contains(other: PointLikeOrAnyShapeOrCollection): boolean;
+    /** Find Shapes within ShapeCollection that entirely contain given other Shape */
+    containers(other: PointLikeOrAnyShapeOrCollection): ShapeCollection | AnyShape;
+    /** Return nearest Shape within this Collection to other given Shape(s) */
+    nearest(other: PointLikeOrAnyShapeOrCollection): AnyShape;
+    /** Shape API */
+    _intersectionsWithEdge(): any;
+    /** Shape API:  Get alle Edges of Shapes */
+    vertices(): ShapeCollection;
+    /** Shape API: Get alle Edges of Shapes */
+    edges(): ShapeCollection;
+    /** Shape API: Get all Wires of Shapes in this Collection */
+    wires(): ShapeCollection;
+    /** Shape API: Get all Faces of Shapes */
+    faces(): ShapeCollection;
+    /** Shape API: Get all Shells of Shapes */
+    shells(): ShapeCollection;
+    /** Shape API: Get all Solids of Shapes */
+    solids(): ShapeCollection;
+    /** Return new ShapeCollection with only the visible Shapes */
+    visible(): ShapeCollection | AnyShape;
+    /** Shape API
+     *   IMPORTANT: ShapeCollection.select() should probably be run in the context
+     *       of the collection, not of individual shapes. Improving this can greatly improve
+     *       chaining like box().select('E||Z').select('E<<X') - where the last select is in context of collection
+    */
+    select(selectString?: string): ShapeCollection;
+    /**  Array API - Pop last Shape from ShapeCollection*/
+    pop(): ShapeCollection;
+    /** Reverse order of the Shapes */
+    reverse(): this;
+    /** Shape API */
+    removeFromScene(): void;
+    /** Shape API */
+    replaceShape(newShapes: Shape | ShapeCollection): void;
+    /** Shape API: Project 3D Shapes on XY plane */
+    _project(planeNormal?: PointLike, all?: boolean): ShapeCollection;
+    /** Shape API: Public Project 3D Shapes on XY plane and add result to Scene */
+    project(planeNormal?: PointLike, all?: boolean): ShapeCollection;
+    /** Shape API: Generate elevation from a given side without adding to Scene */
+    _elevation(side?: Side, all?: boolean): ShapeCollection;
+    /** Shape API: Generate elevation from a given side and add to Scene */
+    elevation(side?: Side, all?: boolean): ShapeCollection;
+    /** Shape API: Generate isometric view from Side or corner of ViewCube ('frontlefttop') or PointLike coordinate
+     *      Does not add to Scene
+     *      Use showHidden=true to output with hidden lines
+     */
+    _isometry(viewpoint?: string | PointLike, showHidden?: boolean): ShapeCollection;
+    /** Shape API: Generate isometric view from Side or corner of ViewCube ('frontlefttop') or PointLike coordinate
+     *     Add to scene
+    *      Use showHidden=true to output with hidden lines
+    */
+    isometry(viewpoint?: string | PointLike, showHidden?: boolean): ShapeCollection;
+    iso(viewpoint?: string | PointLike, showHidden?: boolean): ShapeCollection;
+    /** Array API - Alias for ForEach to have compatitibility with Array */
+    forEach(func: (value: AnyShape, index: number, arr: Array<any>) => void): ShapeCollection;
+    /** Array API - Alias for sort to have compatitibility with Array */
+    sort(func: (a: any, b: any) => number): ShapeCollection;
+    /** Array API - Alias for find to have compatitibility with Array */
+    find(func: (value: any, index: number, arr: Array<any>) => any): any;
+    /** Array API - Filter Shapes in this Collection and return a new ShapeCollection or single Shape
+     */
+    filter(func: (value: any, index: number, arr: Array<any>) => boolean): ShapeCollection;
+    reduce(func: (prevValue: number, curValue: AnyShape, index: number, arr: Array<AnyShape>) => number, startSum: number): number;
+    /** Get Shapes at index. NOTE: We can also use the fake index keys like collection[0] */
+    at(index: number): AnyShape;
+    /** Exclude given Shape from current collection */
+    not(shape: AnyShape): ShapeCollection;
+    /** Check if ShapeCollection is empty */
+    isEmpty(): boolean;
+    /** Alias for length */
+    count(): number;
+    specific(): ShapeCollection | AnyShape;
+    /** Try to calculate the bounding Wire
+     *   Work in progress
+     *    See original code: https://github.com/Open-Cascade-SAS/OCCT/blob/ae1683705ef5c9a7e767c5c873e7d725b04d262f/src/ShapeAnalysis/ShapeAnalysis_FreeBounds.cxx#L89
+    */
+    boundary(): Wire;
+    /** Get Shapes of given type in ShapeCollection */
+    getShapesByType(type: ShapeType): ShapeCollection;
+    getShapesByTypes(types: Array<ShapeType>): ShapeCollection;
+    /** Shape API - Get all subshapes of type from Shapes in Collection */
+    getSubShapes(type: ShapeType): ShapeCollection;
+    /** Get first Shape of Collection */
+    first(): AnyShape;
+    /** Get last Shape of Collection */
+    last(): AnyShape;
+    /** Get all direct children Shapes in this Collection */
+    children(): Array<AnyShape>;
+    /** Alias: remove this eventually! */
+    all(): Array<AnyShape>;
+    /** get lowest Shape type */
+    lowestType(): ShapeType;
+    /** check if this Collection has a specific instance of a Geometry */
+    has(s: AnyShapeOrCollection): boolean;
+    /** Array API */
+    includes(s: AnyShapeOrCollection): boolean;
+    /** Check if this Collection has a Shape of a given type */
+    hasType(type: ShapeType): boolean;
+    /** Array API - Get index of given Shape, if not exists -1 */
+    indexOf(s: Shape): number;
+    /** Array API - */
+    slice(start: number, end: number): ShapeCollection;
+    /** Get the Shapes in current collection that are also in the other one with the same Geometry */
+    getEquals(others: AnyShapeOrCollection): ShapeCollection;
+    /** Get the Shapes that the same, but might be translated
+     *    NOTE: this might not be enough to establish
+     *
+    */
+    getEqualsTranslated(others: AnyShapeOrCollection): ShapeCollection;
+    /** Combine two ShapeCollections and also try to upgrade Shapes that might be combined into higher order Shapes */
+    combine(other: ShapeCollection): ShapeCollection;
+    combined(other: ShapeCollection): ShapeCollection;
+    /** Try to combine collection of shapes into a higher order ShapeCollection */
+    upgrade(): ShapeCollection;
+    /** Try to combine collection of shapes into a higher order ShapeCollection */
+    upgraded(): ShapeCollection;
+    /** Try to combine into higher order Shape of same type of Shapes in Collection */
+    upgradeShapesByType(): this;
+    /** Combine touching Shapes into groups with names like touching{{n=0,1,2}} */
+    groupTouching(): this;
+    /** Check downgrade */
+    checkDowngrade(): ShapeCollection;
+    /** Force unique Geometry based on the equals() method ( not hash ) */
+    unique(tolerance?: number): ShapeCollection;
+    /** Remove doubles based on OC hash */
+    distinct(): ShapeCollection;
+    /** Try to sew Shapes (like Edges, Wires, Faces, Shells) together to create a Face, Shell, Solid or Compound  */
+    _sewed(): AnyShapeOrCollection;
+    /** Combining Linear Shapes (Edges and Wires) into Wires connected by Vertices
+    *    For Edges that overlap this does not work ( union could work: TODO )
+    *    All other Shapes except Edges are kept in the collection
+    *    TODO: Use OC native methods here!
+    */
+    _connectLinearShapes(): this;
+    /** Removing Shapes that are contained by others in the Collection  */
+    _removeContained(): ShapeCollection;
+    /** The same as _removeContained but returns a new Collection */
+    _removedContained(): ShapeCollection;
+    /** Test if the collections are the same */
+    equals(other: AnyShapeOrCollection): boolean;
+    /** Check null or single, and return single value if the case  */
+    checkSingle(): AnyShape | ShapeCollection;
+    /** Collapse ShapeCollection into one Shape if there is only one */
+    collapse(): AnyShape | ShapeCollection;
+    toArray(): Array<AnyShape>;
+    _subtracted(other: AnyShapeOrCollection): ShapeCollection;
+    /** Subtract Shape or ShapeCollection from current ShapeCollection and return new ShapeCollection */
+    subtracted(other: AnyShapeOrCollection): ShapeCollection;
+    subtract(other: AnyShapeOrCollection): ShapeCollection;
+    /** Shape API - Try to union all shapes in Collection (without adding to Scene) */
+    _unioned(other?: AnyShapeOrCollection, noRecurse?: boolean): ShapeCollection | AnyShape;
+    /** Shape API - Try to union all shapes in Collection and add to Scene */
+    unioned(other?: AnyShapeOrCollection): ShapeCollection | AnyShape;
+    /** Shape API - Try to union all shapes in Collection
+     *   TODO: test and make more robust for a variety of Shapes in a Collection
+    */
+    union(): this;
+    /**  Shape API - Add all shapes in the collection to the Scene */
+    addToScene(): ShapeCollection;
+    color(color: any): this;
+    /** Make all Shapes in this ShapeCollection dashed lines */
+    dashed(): this;
+    /** Assign lineWidth to all Shapes in collection  */
+    lineWidth(lw: number): this;
+    /** Shape API - Style all Shapes in Collection */
+    style(newStyle: ObjStyle): ShapeCollection;
+    /** Return this Shape wrapped with a Obj instance for adding it to the scene */
+    object(): Obj;
+    /** Check if there is an Obj container tied to current ShapeCollection
+     *    If so: return it, otherwise make one and return that
+     */
+    checkObj(): Obj;
+    /** NOTE: We don't use set/get here, because it doesnt play well with chaining */
+    name(n?: string): this | string;
+    /** Set name */
+    setName(newName: string): this;
+    /** Get name of container Obj */
+    getName(): string | undefined;
+    /** Shape API - hide all Shapes in Collection */
+    hide(): this;
+    /** Shape API - show all Shapes in Collection */
+    show(): this;
+    /** Flatten all Shapes into new Shapes, align to one plane and return new ShapeCollection
+     *   If an axis is given all Shapes are flattened along that axis and placed at 0 at that axis
+     *   Otherwise we consider shapes as extrusions and we flatten according to _extrudedFace()
+    */
+    flattened(axis?: MainAxis, filterDuplicates?: boolean): AnyShapeCollection;
+    /** Layout Shapes on XY plane within a given Layout order */
+    layout(order: LayoutOrderType, copy: boolean, options: LayoutOptions): ShapeCollection;
+    _placeLine(shape: AnyShape, prevPosition: Point, margin: number, index: number): Point;
+    pack(options: LayoutOptions, copy?: boolean): ShapeCollection;
+    _makeBinPackBox(shape: AnyShape, margin: number, index: number): any;
+    _calculateSizeSkewness(box: any): number;
+    /** Add annotations of this ShapeCollection */
+    addAnnotations(a: Annotation | Array<Annotation>): this;
+    /** Make (semi) automatic dimension lines through the Shapes of this collection at levels (in percentage of total size) along MainAxis within bbox
+     *    @param options:DimensionLevelSettings
+     *    {
+     *       levels: Array< Record<MainAxis,number>
+     *       minDistance: number (0-1)
+     *    }
+     *
+    */
+    autoDim(settings?: DimensionLevelSettings, strategy?: AnnotationAutoDimStrategy): ShapeCollection;
+    /** Shape API - Turn Edges (Line, Arc, Spline etc) into discreet (straight) edges for use in THREE JS
+     *    Flattens all Shapes into one array of edges */
+    toMeshShapes(quality?: MeshingQualitySettings): Array<MeshShape>;
+    /** Output all Shapes in Collection to a single ShapeMeshBuffer */
+    toMeshShapeBuffer(quality: MeshingQualitySettings): MeshShapeBuffer;
+    toData(): Array<Object>;
+    toString(): string;
+    /** Get all edges of 2D XY Shapes in this collection
+     *    Supply true to force all Shapes, even invisible ones!
+    */
+    _get2DXYShapeEdges(all?: boolean): ShapeCollection;
+    /** Get Annotations tied to the collection or sub Shapes  */
+    getAnnotations(onlyVisibleShapes?: boolean): Array<Annotation>;
+    /** Export Shapes that are 2D and on XY plane to SVG
+     *    All shapes will be converted to Edges
+     *    @param options { all:boolean, annotations: boolean, contours:boolean  }
+    */
+    toSVG(options?: toSVGOptions): string;
+    _getDimensionLinesSvgElems(): string;
+    toDXF(options?: toDXFOptions): string | null;
+    /** Convenience method for saving files in browser and node */
+    save(filename?: string, options?: any, shapes?: ShapeCollection | null): void;
+}

package/dist/src/Shell.d.ts

@@ -0,0 +1,48 @@
+import { MakeShellInput, ThickenDirection, AnyShapeOrCollection, AnyShapeSequence, Vector, Point, Shape, Wire, Face, Solid } from './internal';
+type ISolid = Solid;
+export declare class Shell extends Shape {
+    constructor(entities?: any, ...args: Array<any>);
+    _fromOcShell(ocShell: any): Shell;
+    fromAll(entities: MakeShellInput): Shell;
+    fromFace(face: Face): Shell;
+    fromFaces(faces: MakeShellInput, forceShell?: boolean): Shell | AnyShapeOrCollection | null;
+    /** Creates an Shell by interpolating between two (=Loft) or more Edges
+     *  Generally used in the context of filling but might be handy as seperate function */
+    fromEdges(edges: AnyShapeSequence): Shell;
+    /** Create a Shell from a Wireframe of planar Edges or Wires
+     *  See: https://old.opencascade.com/doc/occt-7.5.0/overview/html/occt_user_guides__modeling_algos.html
+     *  docs: https://dev.opencascade.org/doc/refman/html/class_b_o_p_algo___tools.html
+    */
+    fromWireFrame(wireframe: AnyShapeOrCollection): this;
+    /** Get the outer Wire of Shell (private) */
+    _toWire(): Wire;
+    /** Get the outer Wire of Shell */
+    toWire(): Wire;
+    /** Returns the first Face. Handy for one Face Shells (private) */
+    _toFace(): Face;
+    toFace(): Face;
+    _toSolid(): ISolid;
+    toSolid(): ISolid;
+    _setToOc(): void;
+    ocGeom(): any;
+    _ocGeom(): any;
+    /** Get outer Wire of this Shell  */
+    outerWire(): Wire;
+    /** Calculated center of Surface (not middle!) */
+    center(): Point;
+    is2DXY(): boolean;
+    normal(): Vector;
+    /** Get normal at a given Point on the surface */
+    normalAt(point: Point): Vector;
+    /** Thicken the shell to create a Solid (private: without adding to Scene) */
+    _thickened(amount: number, direction: ThickenDirection): ISolid;
+    /** Thicken the shell to create a Solid (private: without adding to Scene) */
+    thickened(amount: number, direction: ThickenDirection): ISolid;
+    /** Private method that is used by thickened */
+    _bridgeThickened(amount: number): ISolid;
+    /** Stitch two Shells together to create a Solid (EXPERIMENTAL) */
+    _bridge(other: Shell): ISolid;
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+}
+export {};

package/dist/src/Sketch.d.ts

@@ -0,0 +1,162 @@
+import { PointLike, Cursor, AnyShape, SketchPlaneName, PointLikeSequence, AnyShapeOrCollection, SelectionString, AnyShapeOrCollectionOrSelectionString, Point, Vector, ShapeCollection, Edge, Face, Brep } from './internal';
+import { gp_Ax3, gp_Trsf } from './wasm/archiyou-opencascade';
+export declare const SKETCH_FILLET_SIZE = 5;
+export declare const SKETCH_CHAMFER_DISTANCE = 10;
+export declare const SKETCH_CHAMFER_ANGLE = 45;
+export interface SketchPlane {
+    origin?: Point;
+    xDir: Vector;
+    yDir: Vector;
+    zDir: Vector;
+}
+interface Operation {
+    type: 'union' | 'subtract' | 'intersection' | 'fillet' | 'bevel';
+    resetOps?: boolean;
+    params?: Object;
+}
+export declare class Sketch {
+    DEFAULT_PLANE_XDIR: number[];
+    DEFAULT_PLANE_YDIR: number[];
+    DEFAULT_PLANE_ZDIR: number[];
+    DEFAULT_PLANE_ORIGIN: number[];
+    DEFAULT_CURSOR: {
+        point: Point;
+        direction: Vector;
+    };
+    PLANE_NAME_TO_PLANE: {
+        [key: string]: SketchPlane;
+    };
+    _oc: any;
+    _brep: Brep;
+    mode: string;
+    workplane: SketchPlane;
+    cursors: Array<Cursor>;
+    activeCursor: Cursor;
+    prevLocalCursor: Cursor;
+    shapes: ShapeCollection;
+    pendingShapes: ShapeCollection;
+    pendingOperations: Array<Operation>;
+    pendingSelections: ShapeCollection;
+    _autoOp: boolean;
+    ocLcs: gp_Ax3;
+    ocGcs: gp_Ax3;
+    ocLocalToWorldTransform: gp_Trsf;
+    ocWorldToLocalTransform: gp_Trsf;
+    /** Start a 2D sketch on specific Plane */
+    constructor(plane?: SketchPlaneName | Face | PointLike, yAxis?: PointLike);
+    /** Set autoOps on or off */
+    autoOp(v: boolean): Sketch;
+    _createSketchLayer(): void;
+    _removeSketchLayer(): void;
+    /** Set workplane from x and y coordinate */
+    _makeWorkplaneFromXY(x: PointLike, y: PointLike): void;
+    /** Set workplane of Sketch from plane string (xy,xz,yz) or side (top, bottom, left, right, front, back) */
+    _planeNameToWorkplane(plane: SketchPlaneName): void;
+    /** Start a 2D Sketch workplane at a Face
+     *  !!!! Not to be confused with on(Shape) which draws on a curved surface using UV coordinates !!!! */
+    _faceToWorkplane(shape: AnyShape): void;
+    /** Drawing directly on a curved surface with UV coords */
+    on(surface: Face): void;
+    /** Prepare transformations needed for turning local coords into world ones */
+    _setWorkplaneTransforms(): void;
+    /** Set origin of sketch */
+    origin(point: PointLike): Sketch;
+    /** This is the active cursor of all cursors in this.cursors */
+    _setActiveCursor(cursor?: Cursor): void;
+    /** Set given Cursor as all cursors - in world coordinates */
+    _setCursor(cursor: Cursor | PointLike): void;
+    /** Update cursor based on (just created) Shape */
+    _setCursorByShape(shape: AnyShape): void;
+    /** Used for relative coordinates between arguments.
+     *  Like arcTo([100,100],['+100','+100']) - second Point is relative to [100,100], so we need to set it!
+     *  NOTE: problem with using relative polar coordinates because we don't know arc tangent yet!
+     * */
+    _setPrevLocalPoint(point: PointLike): void;
+    /** Resolve PointLike based on prevLocalPoint or Cursor */
+    _resolvePointLikeToLocalPoint(point: PointLike, ...args: any[]): Vector | Point;
+    /** Transform PointLike to absolute World coordinate with:
+     *
+     *      - Resolve relative coordinates (cartesian and polar) - if not the same as cursor, can be set by prevLocalPoint
+     *      - Transform local coords to world coordinates
+    */
+    _transformPointToWorld(point: PointLike): Point;
+    /** Transform local coordinate Point to world coordinates */
+    _toWorld(point: Point): Point;
+    _toLocal(p: PointLike): Point;
+    _toLocalCursor(cursor: Cursor): Cursor;
+    /** Everything after a new Edge */
+    _processNewEdge(newEdge: Edge): void;
+    /** After creating a new Shape we see if we need to run operations on them */
+    _doPendingOps(newShapes: AnyShapeOrCollection): void;
+    /** Do pending operation */
+    _doOperation(op: Operation, newShapes: AnyShapeOrCollection): void;
+    /** Convenience method combining smartFaceOps and afterNewShapes */
+    _processNewFace(newFace: Face, autoOp?: boolean): void;
+    /** Apply union or subtraction based on relation of new Shape with existing ones in this.shapes  */
+    _doFaceOps(newFace: Face, autoOp?: boolean): void;
+    /** Update pending Shapes after new Shapes */
+    _setPendingShapes(newShapes: AnyShapeOrCollection): void;
+    /** Combine All linear Shapes into Wires */
+    combine(): void;
+    /** Move cursor to local coordinate */
+    moveTo(point: PointLike, ...args: any[]): Sketch;
+    /** Line from active cursors to given point */
+    lineTo(point: PointLike, ...args: any[]): Sketch;
+    /** Make Arc from active cursors to given Point */
+    arcTo(mid: PointLike, end: PointLike): Sketch;
+    /** Make Spline from active cursors to given Point */
+    splineTo(points: PointLikeSequence, ...args: any[]): Sketch;
+    /** Combine all Edges and Wires and try to close it into single Shapes */
+    close(): Sketch;
+    /** Some created Faces need to be rotated to face workplane */
+    _rotateFaceToWorkplane(face: Face): void;
+    rectTo(point: PointLike, ...args: any[]): Sketch;
+    rect(width?: number, height?: number): Sketch;
+    circleTo(point: PointLike, ...args: any[]): Sketch;
+    circle(radius: number): Sketch;
+    /** Make all shapes pending */
+    all(): Sketch;
+    /** Set pendingShapes as temporary (will not be imported) */
+    isTemp(): Sketch;
+    /** Select certain parts of pendingShapes for operations to use */
+    select(selectionString: SelectionString): Sketch;
+    /** Set vertices of pendingShapes as cursors */
+    atVertices(): Sketch;
+    /** Get and reset pending selections */
+    _getPendingSelections(): ShapeCollection;
+    /** Mirror all Shapes in Sketch */
+    mirror(origin?: PointLike, direction?: Vector, autoOp?: boolean): Sketch;
+    /** Offset pendingShapes a given amount with a specific type (tangent, arc, intersection) */
+    offset(amount?: number, type?: string): Sketch;
+    /** Offset pendingShapes of Sketch Shapes a given amount with a specific type (tangent, arc, intersection) */
+    offsetted(amount?: number, type?: string): Sketch;
+    thicken(amount: number): this;
+    thickened(amount: number): this;
+    /** Apply fillet to Edges or Faces */
+    fillet(size?: number, at?: AnyShapeOrCollectionOrSelectionString): Sketch;
+    /** Do fillet operation on last added Edge */
+    doFillet(newEdge: Edge, params: any): void;
+    chamfer(distance?: number, angle?: number, vertices?: AnyShapeOrCollectionOrSelectionString): Sketch;
+    /** Do chamfer operation on last added Edge */
+    doChamfer(newEdge: Edge, params: {
+        [key: string]: any;
+    }): void;
+    /** Combine Face Shapes into new one(s) */
+    union(): Sketch;
+    doUnion(newShapes: ShapeCollection, params: any): void;
+    /** Alias for union: Combine Face Shapes into one(s) */
+    add(): Sketch;
+    subtract(): Sketch;
+    doSubtract(newShapes: ShapeCollection, params: any): void;
+    cut(): Sketch;
+    intersection(): Sketch;
+    overlap(): Sketch;
+    /** Just get Shapes without adding to Scene (used by IO) */
+    getShapes(): ShapeCollection | AnyShape;
+    import(): ShapeCollection | AnyShape;
+    /** Alias for import */
+    importSketch(): ShapeCollection | AnyShape;
+    /** Alias for import */
+    end(): ShapeCollection | AnyShape;
+}
+export {};