archiyou 0.7.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/internal'
+export {}

package/dist/src/Annotator.d.ts

@@ -0,0 +1,55 @@
+import { PointLike, AnyShape, DimensionOptions, DimensionLevelSettings, Annotation, AnnotationData, AnnotationAutoDimStrategy, Brep, ShapeCollection, Bbox, DimensionLine } from './internal';
+export declare class Annotator {
+    DIMENSION_BOX_OFFSET_DEFAULT: number;
+    _oc: any;
+    _brep: Brep;
+    name: string;
+    annotations: Array<Annotation>;
+    constructor();
+    /** Make dimension line. Is added to list automatically */
+    dimensionLine(start?: PointLike, end?: PointLike, options?: DimensionOptions, autoAdd?: boolean): DimensionLine;
+    /** Make a Dimension Line without adding to list yet! */
+    makeDimensionLine(start?: PointLike, end?: PointLike, options?: DimensionOptions): DimensionLine;
+    /** Create dimension lines for bounding box of Shape */
+    dimensionBox(shape: AnyShape): void;
+    getAnnotations(): Array<Annotation>;
+    getAnnotationsInBbox(bbox: Bbox, margin?: number): Array<Annotation>;
+    addAnnotations(annotations: Array<Annotation>): this;
+    setAnnotations(annotations: Array<Annotation>): this;
+    /** Get all annotations in one Array. See interfaces like DimensionLineData */
+    getAnnotationsData(): Array<AnnotationData>;
+    /** Reset annotations */
+    reset(): void;
+    autoDim(shapes: ShapeCollection, options?: DimensionOptions | DimensionLevelSettings, strategy?: AnnotationAutoDimStrategy): ShapeCollection | DimensionLine[];
+    /** Try to determine the best auto dimensioning strategy
+     *  These strategies are now available:
+     *      - Part: One clear 2D Shape (possible with holes). Dimensioning mostly focused on producing that Shape
+     *      - Levels: Complex collection of Shapes. Dimensioning along levels of the collection
+    */
+    _getAutoDimStrategy(shapes: ShapeCollection): AnnotationAutoDimStrategy;
+    /** Generate dimension lines for a 2D Part on XY plane slighly focused on production by cutting
+     *      We take an approach of dimension line levels:
+     *         1. Outset bbox of Shape: the stock dimensions
+     *         2. Dimension the edges on, and parallel to the bbox outside
+     *         3. Add any dimensions of edges that are not yet done. Avoid doubles
+     *
+     * @param shapes Shape or ShapeCollection to dimension
+     * @returns ShapeCollection
+     */
+    autoDimPart(shapes: ShapeCollection, options?: DimensionOptions): ShapeCollection;
+    /** Make (semi) automatic dimension lines through the Shapes of this collection at levels (in percentage of total size or absolute coords) along MainAxis within bbox
+     *    @param options:AutoDimSettings
+     *    {
+     *       levels: Array< Record<MainAxis,number>
+     *       minDistance: number (0-1)
+     *    }
+     *
+     */
+    autoDimLevels(collection: ShapeCollection, settings?: DimensionLevelSettings): Array<DimensionLine>;
+    /** Filter out the same annotations
+     *  See isSame for config flags
+     */
+    unique(annotations: Array<Annotation>, flags?: Record<string, any>): Array<Annotation>;
+    /** Remove annotations that have same value and are close to each other */
+    removeSameAtSmallDistance(d: number, sameFlags?: Record<string, any>): this;
+}

package/dist/src/AnnotatorBaseAnnotation.d.ts

@@ -0,0 +1,16 @@
+import { AnyShape, Bbox, AnnotationType } from './internal';
+export declare class BaseAnnotation {
+    uuid: string;
+    value: string | number;
+    _type: AnnotationType;
+    constructor(type?: AnnotationType);
+    static isAnnotation(obj: any): boolean;
+    /** Type of Annotation, reimplemented in extended classes */
+    type(): AnnotationType;
+    update(): void;
+    sameId(): string | null;
+    inBbox(bbox: Bbox): boolean;
+    toSVG(): string | null;
+    toShape(): AnyShape | null;
+    toData(): any;
+}

package/dist/src/AnnotatorDimensionLine.d.ts

@@ -0,0 +1,92 @@
+import { DxfBlock } from '@tarikjabiri/dxf';
+import { MainAxis, PointLike, AnyShape, AnyShapeOrCollection, ModelUnits, DimensionLineData, DimensionOptions, AnnotationType, Point, Vector, Edge, BaseAnnotation } from './internal';
+export declare class DimensionLine extends BaseAnnotation {
+    DIMENSION_OFFSET_DEFAULT: number;
+    DIMENSION_ROUND_DEFAULT: boolean;
+    _initialized: boolean;
+    targetStart: Point;
+    targetEnd: Point;
+    targetShape: AnyShape;
+    linkedTo: AnyShapeOrCollection;
+    static: boolean;
+    units: ModelUnits;
+    offsetVec: Vector;
+    offsetLength: number;
+    ortho: boolean | MainAxis;
+    _orthoAxis: MainAxis;
+    round: boolean;
+    roundDecimals: number;
+    textSize: number;
+    interactive: boolean;
+    showUnits: boolean;
+    param: string;
+    constructor(start?: PointLike, end?: PointLike, options?: DimensionOptions);
+    /** Check if a given object is a DimensionLine  */
+    static isDimensionLine(o: any): boolean;
+    /** (Re)init dimension line */
+    init(start: PointLike, end: PointLike, options?: DimensionOptions): this;
+    /** Generate a dimension line from this Edge */
+    fromEdge(edge: Edge, options?: DimensionOptions): this;
+    /** Link this Annotation to given Shape or ShapeCollection
+     *  This helps with more advanced dimensioning and retrieving Dimension when exporting Shapes */
+    link(to: AnyShapeOrCollection): this;
+    /** Recurse parents to find main parent Shape of given shape */
+    _getParentShape(s: AnyShapeOrCollection): AnyShapeOrCollection | null;
+    _getDynamicValue(): number;
+    type(): AnnotationType;
+    /** Vector from target start to end, not normalized */
+    targetDir(): Vector;
+    /** Vector from dimension line start to end */
+    dir(): Vector;
+    /** Middle Point of this DimensionLine */
+    targetMiddle(): Point;
+    /** Offset Vector of length offsetLength from target points to Dimension line */
+    offset(): Vector;
+    /** Update when linked Shape is updated */
+    update(): void;
+    /** Update position after linked Shape has moved
+     *  !!!! IMPORTANT !!!! Improve this method
+    */
+    updatePosition(): void;
+    /** Calculate the direction for offsetting from target
+     *  How to offset depends on dimension line type: normal, ortho
+    */
+    _calculateOffsetVec(overwrite?: boolean): Vector;
+    /** Calculate a offset length */
+    _calculateAutoOffsetLength(): number;
+    /** The start and end point of DimensionLine in original coordinate system
+     *  Where the points are depends on type of dimension line. Normal or othogonal
+    */
+    _calculatePoint(at: 'start' | 'end'): Point;
+    /** Get rotation in SVG coordinate system (so mirror y!) */
+    getSVGRotation(): number;
+    /** Set static value  */
+    setValue(v: number | string): this;
+    setOptions(o: DimensionOptions): this;
+    setOffsetVec(v: PointLike): this;
+    /** bind parameter to this dimension line and make it interactive */
+    bindParam(paramName: string): void;
+    /** Generic Shape method (every Annotation class should have this!) */
+    toShape(): Edge;
+    /** Make a Line Edge out this DimensionLine */
+    toEdge(): Edge;
+    targetEdge(): Edge;
+    sameId(flags?: Record<string, boolean>): string | null;
+    isSame(other: DimensionLine, flags?: Record<string, boolean>): boolean;
+    /** To distinguish between Dimension Lines we can calculate the y coord of the offset projected from the position  */
+    _projYAxis(): number;
+    /** Output to data (to be send from Webworker to main app) */
+    toData(): DimensionLineData;
+    /** Generate SVG for this dimension line
+     *     if 3D the Dimension Line is projected to XY plane
+     *     NOTE: we need to transform from Archiyou coordinate system to the SVG one (flip y)
+     */
+    toSVG(): string;
+    /** Generate a line segment in SVG (with SVG coords) */
+    _makeSvgLinePath(start: PointLike, end: PointLike): string;
+    /** Place SVG arrow on position and rotation. Tip of the arrow is pivot */
+    _makeSvgArrow(at: PointLike, flip?: boolean): string;
+    _makeSvgTextLabel(at: PointLike, text: string): string;
+    /** Export Annotation to DXF aligned dimension line */
+    toDXF(dxf: DxfBlock): this;
+}

package/dist/src/Bbox.d.ts

@@ -0,0 +1,126 @@
+import { AnyShape, PointLike, MainAxis, Side, Brep, Point, Vertex, Edge, Face, Solid, AnyShapeOrCollection } from './internal';
+export declare class Bbox {
+    _oc: any;
+    _brep: Brep;
+    _ocBbox: any;
+    _parent: AnyShapeOrCollection;
+    position: Point;
+    bounds: Array<number>;
+    /** Create 2D or 3D Bbox from two Point spanning up the box */
+    constructor(min?: PointLike, max?: PointLike);
+    _clearOcBbox(): void;
+    /** Link to Shape or ShapeCollection
+     *  Used to keep track of _parent chain for Bbox subshapes
+     */
+    setParent(p: AnyShapeOrCollection): void;
+    create(min: PointLike, max: PointLike): any;
+    /** Set boundaries of Bbox from OC Bbox */
+    setBounds(): number[];
+    /** Make string hash based on values to be able to identify quickly */
+    hash(round?: boolean): string;
+    /** Copy this Bounding Box */
+    copy(): Bbox;
+    /** Update properties (bounds and position) based on _ocBbox */
+    updateFromOcBbox(): void;
+    /** Get Point of left, front, bottom corner */
+    min(): Point;
+    minAtAxis(a: MainAxis): any;
+    maxAtAxis(a: MainAxis): any;
+    /** Get maximum point (right,top,back) */
+    max(): Point;
+    minX(): number;
+    maxX(): number;
+    minY(): number;
+    maxY(): number;
+    minZ(): number;
+    maxZ(): number;
+    /** Get center of Bounding Box */
+    center(): Point;
+    /** Get height of Bounding Box */
+    height(): number;
+    /** Get depth of Bounding Box */
+    depth(): number;
+    /** Get width of Bounding Box */
+    width(): number;
+    /** Maximum size of Bbox */
+    maxSize(): number;
+    /** Maximum size of Bbox */
+    minSize(): number;
+    /** At what axis is the bbox the largest */
+    maxSizAxis(): MainAxis;
+    /** Get frontal Face (3D) or Edge (2D) */
+    front(): Vertex | Edge | Face;
+    /** Get back Face (3D) or Edge (2D) */
+    back(): Vertex | Edge | Face;
+    /** Get left Face (3D) or Edge (2D) */
+    left(): Vertex | Edge | Face;
+    /** Get left Face (3D) or Edge (2D) */
+    right(): Vertex | Edge | Face;
+    /** Get left Face (3D) or Edge (2D) */
+    top(): Vertex | Edge | Face;
+    /** Get left Face (3D) or Edge (2D) */
+    bottom(): Vertex | Edge | Face;
+    /** Get one of the 8 Vertices of the Bbox
+     *  @param - a string like 'leftfront', 'bottomright'
+     *  Order of sides does not matter
+     *  TODO: Old method. Need refactoring!
+    */
+    corner(where: string): Point;
+    /** Get the diagonal of Bounding Box as Vertex (zero size Bbox) or Edge */
+    diagonal(): Vertex | Edge;
+    /** Get position of Bbox based on percentages of x,y,z */
+    getPositionAtPerc(p: PointLike, ...args: any[]): Point;
+    /** Enlarge by offsetting current Bbox in all direction a given amount. Returns a new Bbox. */
+    enlarged(amount: number): Bbox;
+    /** Return a new Bbox by adding another */
+    added(other: Bbox): Bbox;
+    /** Check if Bounding Box of zero size so a Point */
+    isPoint(): boolean;
+    /** Checks if sizes along axis are zero */
+    _sizesAreZero(): Array<boolean | boolean | boolean>;
+    /** Bbox has only one size dimension (the others are zero) */
+    is1D(): boolean;
+    /** Check if Bounding Box is 2D */
+    is2D(): boolean;
+    is3D(): boolean;
+    /** The axis that is missing in 2D bbox */
+    axisMissingIn2D(): MainAxis | null;
+    axes2D(): Array<MainAxis>;
+    /** Along what axis is this 1D Bbox */
+    sizeAxis1D(): MainAxis | null;
+    /** Axis on which the bbox has a size */
+    hasAxes(): Array<MainAxis>;
+    /** Get size of current Bbox along given axis */
+    sizeAlongAxis(axis: MainAxis): number;
+    /** Get Shape from this Bounding Box */
+    shape(): Vertex | Edge | Face | Solid | null;
+    /** Make Line from 1D Bbox */
+    line(): Edge | null;
+    /** Create 2D Rectangle Face from Bbox */
+    rect(): Face;
+    /** returns a Box Shape for this Bbox if not 2D, otherwise null */
+    box(): Solid | null;
+    /** Return flipped Bbox that is mirrored in x-axis. For certain 2D ops */
+    flippedY(): Bbox;
+    /** Gets the Edge seperating width in two equal halves */
+    widthHalfLine(): Edge;
+    /** Gets the Edge seperating depth in two equal halves */
+    depthHalfLine(): Edge;
+    /** Get Sub Shapes associated with given sides
+        @param side - combinations of front|back|right|left|top|bottom
+        NOTE: we use _getSide for now - but we might refactor
+    */
+    getSidesShape(sidesString: string): Face | Edge | Vertex;
+    /** Get individual Bbox side shapes based on sidestring
+     *  @param sidesString any combination between front/back,left/right,top/bottom
+     */
+    _getIndividualSideShapes(sidesString: string): Record<Side, Face | Edge | Vertex>;
+    /** Get area of bbox */
+    area(): number;
+    contains(other: AnyShape): boolean;
+    _containsBbox(other: Bbox): boolean;
+    toData(): Array<number>;
+    toString(): string;
+    /** Get side of Bbox - NOTE: Some sides can be zero length */
+    _getSide(side: string): Vertex | Edge | Face;
+}

package/dist/src/Beams.d.ts

@@ -0,0 +1,316 @@
+import { ArchiyouApp, AnyShape, Alignment, PointLike, Point, Vector, Edge, Wire, Face, Shell, Solid, ShapeCollection } from './internal';
+export declare class Beams {
+    _ay: ArchiyouApp;
+    activeSection: BeamSection;
+    beams: Array<Beam>;
+    constructor(ay?: ArchiyouApp);
+    setArchiyou(ay: ArchiyouApp): void;
+    /** Set handy globals on a given context */
+    setGlobals(scope: any): void;
+    setBeamCreationMethods(): void;
+    reset(): void;
+    new(type?: BeamType, length?: number): Beam;
+    /** TODO: Resolve all joints of Beam system */
+    join(): void;
+    getLastBeam(): Beam | null;
+    getPrevBeam(b: Beam): Beam;
+}
+/**
+ *  Beam is fully defined by:
+ *
+ *   - base line: start position, length and direction (pitch and rotation)
+ *      This is the diagramatic representation of a Beam and is the most important abstraction
+ *   - section (2D section) and its alignment to the line
+ *
+ *  Defining a Beam goes step-wise, either by settings primary properties directly
+ *  but probably more by defining the type (Beam.post(), Beam.brace()) and relations.
+ *
+ *  The input of the user is focused on defining the Beam (type(), length(), at()) and
+ *  its context (place()) and we can determine the most probably solution based on the most practical outcomes.
+ *  This operates on the diagramatic (base-line only) representation of a system of beams
+ *
+ *  At the last phase of definition the user can tune the details of the Beam, which operates on the real solid
+ *  representation of the beams
+ *
+ */
+export declare class Beam {
+    _type?: BeamType;
+    _flags?: BeamFlags;
+    _id: string;
+    _serial: number;
+    _parent: Beams;
+    _length: number;
+    _position: Point;
+    _pitch: number;
+    _rotation: number;
+    _roll: number;
+    _alignment: Alignment;
+    _shape: AnyShape;
+    _baseLine: Edge;
+    _section: BeamSection;
+    _others: Array<Beam>;
+    _relations: Array<BeamRelation>;
+    _operations: Array<BeamOperation>;
+    name: string;
+    constructor(parent: Beams);
+    length(l: number, updateShape?: boolean): this;
+    direction(): Vector;
+    center(): Point | null;
+    _setLengthFrom(start: PointLike, end: PointLike): this;
+    _getLengthFromShape(): number;
+    /** Set position of the beam */
+    at(p: PointLike): this;
+    /** Place this Beam along a Line given by start and end position */
+    along(start: PointLike, end: PointLike, autoLength?: boolean): this;
+    _updateBaseLine(): void;
+    move(p: PointLike, ...args: any[]): this;
+    /** Set absolute pitch angle in degrees of this Beam */
+    pitch(angle: number): this;
+    /** Set absolute rotation to given angle */
+    rotation(angle: number): this;
+    /** Rotate around Z-axis in degrees */
+    rotate(d: number): this;
+    /** Get start of base line of Beam
+     *  Start is always the lowest, most left position of the base line
+    */
+    start(): Point;
+    /** Get end base line of Beam */
+    end(): Point;
+    /** Make sure of the given two Points start is the most bottom and left */
+    _checkStartEnd(start: PointLike, end: PointLike): [Point, Point];
+    beam(length?: number): this;
+    post(length?: number): this;
+    stud(length?: number): this;
+    brace(length?: number): this;
+    /** Make Section Face at start position with correct orientation for the Beam
+     *  NOTE: With sweep() we anticipate more complex sections, like I-beams, cylinders etc.
+     *  TODO: use cache for small speed up?
+    */
+    _getOrientatedSectionFace(): Face;
+    /** Get Section face align to center of Beam */
+    _getOrientatedSectionFaceCentered(): Face;
+    /** Get offset Vector from baseline to center of Beam section */
+    _getBaseLineToSectionCenterVec(): Vector;
+    /** Get center line of Beam */
+    _getSectionCenterToPivot(): Vector;
+    _getCenterLine(): Edge;
+    /** Set Beam solid Shape from base properties or replace if existing
+     *  NOTE: base line has priority over the solid Shape!
+    */
+    _setShape(): this;
+    /** Get normal of top face of Beam */
+    _getTopFaceNormal(): Vector;
+    /** Get (simplified) top Face of Beam */
+    _getTopTestFace(): Face;
+    /** Get the cutting top Edge given a cutting Face
+     *  NOTE: Does not test if it even cuts!
+    */
+    _getTopCutEdge(intersectionFace: Face): Edge;
+    /** Get normal of side face of Beam
+     *  The main side is the one facing y=-1 when beam is places along x-axis with start at origin
+    */
+    _getSideFaceNormal(): Vector;
+    /** Get origin for operation (a la BTLX) */
+    _getOperationOrigin(): Point;
+    _getOperationTestLine(): Edge;
+    /** Add debug shapes */
+    debug(): void;
+    /** Apply an operation to this Beam */
+    apply(op: BeamOperation): void;
+    checkDuplicateOperation(op: BeamOperation): this;
+    /** Add parametric Cut operation to Beam and update its Shape */
+    cut(start: number, angle?: number, inclination?: number): this;
+    /** Cut at point or along a given Face */
+    cutAt(other: PointLike | Face): this;
+    /** Add parametric Extend operation to Beam and update its Shape */
+    extend(amount: number, side: BeamTail): void;
+    /** Add parametric Extend operation but with a Shape as input
+     *  We extend to fully overlap between this Beam and other Beam or Shape
+    */
+    extendTo(other: Beam | AnyShape | PointLike, toOtherSide?: BeamExtendToOtherSide): this;
+    setShape(s: AnyShape): this;
+    /** Remove any shape from inner Shape
+     *  TODO: Invent something with operation stack to make this parametric
+     */
+    _subtract(other: AnyShape): this;
+    /** WARNING: Unions can be remarkably slow! */
+    _union(other: AnyShape): this;
+    /** Rebuild Shape to remove ugly edges
+        TODO: This can be improved into something that builds
+            the Beam shape from scratch by applying operations
+    */
+    _rebuildShape(): void;
+    /** cut Shape of Beam at given Face */
+    _cutShape(at: Face): this;
+    _setFromStartEnd(): this;
+    /** Get line along axis of Beam that starts from the pivot to the end of the Beam */
+    _setBaseLine(cached?: boolean): Edge;
+    /** Get Face at start of Beam from its current Solid Shape
+     *  TODO: How to deal parametrically with operations that leave a tail with multiple Faces
+    */
+    getFaceAt(side: BeamTail): Face;
+    getFaceAtStart(): Face;
+    getFaceAtEnd(): Face;
+    type(t: BeamType, length?: number): this;
+    /**
+     *  Position this Beam from the top onto one or more other beams
+     *  Relations will be formed, that are resolved into joints
+     */
+    place(others: BeamOrBeamSequence, at?: BeamBaseLineAlignment): this;
+    /** Add Relation from current Beam to others at a given location
+     *  Based on the other Beams and location a BeamRelationType is determined (or manually set)
+     */
+    _addRelation(other: Beam, at: Point, type?: BeamRelationType): void;
+    /** Relations can be either along a Beam (including start) or at the end ('on')
+     *  which defines together with number of Beams the exact Relation type
+    */
+    _getBeamRelationBaseLocation(location: BeamBaseLineAlignment): 'along' | 'on';
+    /** The point on the base line of other beams to place this beam on
+     *  @return Point where this Beam is placed at
+    */
+    _placeAt(other: Beam, atOther?: BeamBaseLineAlignment): Point;
+    /** Place this Beam in relation to two or more others
+     *  @param others the other Beams to place the current at
+        @param atOther alignment where to place. Use 1 if same (like with posts) or multiple to define for all other Beams
+    */
+    _placeAtOthers(others: Array<Beam>, atOther?: BeamBaseLineAlignment | Array<BeamBaseLineAlignment>, autoLength?: boolean): [Point, Point];
+    /** Create Diagonal between current and other beam
+     *  @param endBeam
+     */
+    diagonal(endBeam: Beam, startAt?: BeamBaseLineAlignment): this;
+    /** point along base line of Beam
+     *  @param at start,end, middle/center or [0-1] or distance from start in model units (like mm)
+     */
+    _pointAtBaseLine(at?: BeamBaseLineAlignment): Point;
+    /** Resolve (unresolved) relations to joints */
+    join(type: BeamJointType, options: BeamJointOptions): void;
+    _resolveRelationToJoint(r: BeamRelation, type: BeamJointType, options: BeamJointOptions): any;
+    /** Make Shells from Wire projections
+     *  Uses the powerful Shell.fromWireframe algorithm
+     */
+    _makeShellsFromProjections(projections: ShapeCollection, on: AnyShape): ShapeCollection;
+    _makeShellFromProjection(proj: Wire, on: AnyShape): Shell;
+    /** Get the intersection Shape of  (extended) current and other beams
+     *
+    */
+    _getExtendedIntersection(curExt: AnyShape, otherExt: AnyShape): AnyShape;
+    /**
+     * Extend current Beam a given amount or to a given Point, Wire or Face and return Shape
+     *  NOTE: The direction of the Beam stays the same
+     *  NOTE: Depending on the to input this returns a butt or cutted Beam - TODO: Make this more transparent
+     */
+    _getExtendedShapeAndDir(to: number | PointLike | Wire | Face, at?: Point | BeamBaseLineAlignment): [Solid, Vector];
+    /** Simpler Shape that is extended on both sides equally */
+    _getExtendedTestShape(): Solid;
+    _getExtendedTestIntersection(to: Beam | AnyShape | PointLike): AnyShape;
+    /** Get the project Section of this Beam onto another Solid
+     *  IMPORTANT: Results might be inaccurate when difference between projections are minor!
+    */
+    _getProjectedSections(other: Solid, dir: Vector): ShapeCollection;
+    /** Get a extended Line Edge in direction of Beam along baseline */
+    _getTestBaseLine(): Edge;
+    /** A butt joint is the most simple joint with one mutual touching line or face
+     *  either by combining two orthogonal Beams without any angled cuts, one beam has priority over the other
+     *  Or cutting one Beam at an angle to place at the other
+     *
+     *  Options (TODO):
+     *      strategy: butt-only, cutone
+     *      auto priority: top, horizontal
+     *      location: outside, baseline
+     */
+    _resolveJointButt(inp: BeamJointResolveInput, options?: BeamJointOptionsButt): BeamJointResult;
+    /** A miter joint is characterized by clean outside angles (see for example SVG stroke style)
+     *  that can be achieved by either a symmetrical cut on both Beams
+     *  or assymmetrically extending and cutting with one Beam that has priority
+     *  For pitch=0 an assymmetrical Miter joint is the same as a butt joint
+    */
+    _resolveJointMiter(inp: BeamJointResolveInput, options?: BeamJointOptions): BeamJointResult;
+}
+export type BeamType = 'beam' | 'post' | 'stud' | 'rafter' | 'diagonal' | 'brace' | 'nogging' | 'girt';
+export type BeamSectionOrientation = 'flat' | 'up' | 'rect';
+export type BeamOrBeamSequence = Array<Beam> | Beam;
+export type BeamTail = 'start' | 'end';
+export type BeamBaseLineAlignment = BeamTail | 'center' | 'middle' | number;
+export type BeamRelationType = 'support' | 'on' | 'along' | 'between' | 'brace' | 'diagonal';
+export type BeamJointType = 'butt' | 'miter' | 'lap';
+export type BeamExtendToOtherSide = 'in' | 'out';
+declare class BeamSection {
+    _width: number;
+    _height: number;
+    _orientation?: BeamSectionOrientation;
+    constructor(width?: number, height?: number);
+    set width(w: number);
+    set height(h: number);
+    get height(): number;
+    get width(): number;
+    _setOrientation(): BeamSectionOrientation;
+    copy(): BeamSection;
+}
+/** Describes a relation between two Beams at one Location
+ *  Most relations already make the number of Beams implicit
+ *  Like:
+ *      - on: 1 other Beam
+ *      - between: 2 other Beams
+ *
+ *  Different Relations can be combined by location into Joints and resolved into fitting Shapes
+*/
+declare class BeamRelation {
+    from: Beam;
+    to: Beam;
+    at: Point;
+    type: BeamRelationType;
+    resolved: boolean;
+    constructor(from: Beam, to: Beam, type?: BeamRelationType, at?: Point);
+}
+/** Flags that keep track of state and behaviour of Beam */
+interface BeamFlags {
+    fit?: boolean;
+    priority?: number;
+    placeOtherAt?: BeamBaseLineAlignment;
+    autoLength?: boolean;
+    autoRotation?: boolean;
+    autoPitch?: boolean;
+    ortho?: boolean;
+}
+interface BeamJointResolveInput {
+    relation: BeamRelation;
+    fromExtended: AnyShape;
+    toExtended: AnyShape;
+    intersection: AnyShape;
+    fromProjIn?: Wire;
+    fromProjOut: Wire;
+    fromProjInShell?: Shell;
+    fromProjOutShell?: Shell;
+    toProjIn?: Wire;
+    toProjOut: Wire;
+    toProjInShell?: Shell;
+    toProjOutShell?: Shell;
+    flags?: BeamJointResolveFlags;
+}
+interface BeamJointResolveFlags {
+    fullIntersection: boolean;
+    largestBeamIntersection: Beam;
+    orthogonal: boolean;
+}
+/** Specific options to solve a joint */
+type BeamJointButtStrategy = 'butt-only' | 'cutone';
+interface BeamJointOptions {
+    strategy?: BeamJointButtStrategy;
+    at?: 'outside' | 'baseline';
+}
+interface BeamJointOptionsButt extends BeamJointOptions {
+    buttAlign: BeamExtendToOtherSide;
+}
+interface BeamJointResult {
+    input: BeamJointResolveInput;
+    output: any;
+}
+declare class BeamOperation {
+    id: string;
+    type: string;
+    _btlx: boolean;
+    constructor(type: any);
+    hash(): string;
+    apply(to: Beam): this;
+}
+export {};