geometrix/dist/index.d.ts

The 2D geometry engine of the parametrix

declare const colors: {
    point: string;
    line: string;
    vector: string;
    contour: string;
    mainOuter: string;
    mainInner: string;
    mainB: string;
    second: string;
    secondB: string;
    dynamics: string;
    ruler: string;
    origin: string;
    reference: string;
    mouse: string;
};
interface tCanvasAdjust {
    init: number;
    xMin: number;
    yMin: number;
    xyDiff: number;
    shiftX: number;
    shiftY: number;
    scaleX: number;
    scaleY: number;
}
declare function point2canvas(px: number, py: number, iAdjust: tCanvasAdjust): [number, number];
declare function canvas2point(cx: number, cy: number, iAdjust: tCanvasAdjust): [number, number];
declare function canvasTranslatePolar(cx: number, cy: number, ia: number, il: number): [number, number];
declare function radius2canvas(iRadius: number, iAdjust: tCanvasAdjust): number;
declare function adjustZero(): tCanvasAdjust;
declare function adjustCopy(iAdjust: tCanvasAdjust): tCanvasAdjust;
declare function adjustInit(xMin: number, xMax: number, yMin: number, yMax: number, cWidth: number, cHeight: number): tCanvasAdjust;
declare function adjustCenter(px: number, py: number, iAdjust: tCanvasAdjust): tCanvasAdjust;
declare function adjustRect(p1x: number, p1y: number, p2x: number, p2y: number, cWidth: number, cHeight: number): tCanvasAdjust;
declare function adjustScale(iFactor: number, iAdjust: tCanvasAdjust): tCanvasAdjust;
declare function adjustTranslate(p1x: number, p1y: number, p2x: number, p2y: number, iAdjust: tCanvasAdjust): tCanvasAdjust;
declare function adjustMini(widthOrig: number, widthTarget: number, iAdjust: tCanvasAdjust): tCanvasAdjust;

declare const tolerance: number;
declare function degToRad(degrees: number): number;
declare function radToDeg(rad: number): number;
declare function roundZero(ix: number): number;
declare function withinZero2Pi(ia: number): number;
declare function withinPiPi(ia: number): number;
declare function withinZeroPi(ia: number): number;
declare function withinHPiHPi(ia: number): number;
declare function orientedArc(aStart: number, aStop: number, ccw: boolean): number;
declare function isWithin(aNew: number, aStart: number, aStop: number, ccw: boolean): boolean;
/**
 * Calculate the coordiantes [X,Y] of B, starting from A[x,y] and translate with angle aAB and length lAB
 *
 *  @param ax - X-coordiante of point A
 *  @param ay - Y-coordiante of point A
 *  @param aAB - angle of translation vector AB in radian
 *  @param lAB - length of translation vector AB
 *  @returns [Bx, By] coordinates of point B
 */
declare function pointCoord(ax: number, ay: number, aAB: number, lAB: number): [number, number];
declare function ffix(ifloat: number): string;

declare function rightTriLaFromLbLc(ilb: number, ilc: number): number;
declare function rightTriLbFromLaLc(ila: number, ilc: number): number;
declare function lcFromLaLbAc(la: number, lb: number, ac: number): number;
declare function aCFromLaLbLc(la: number, lb: number, lc: number): number;
declare function aCFromAaAb(iaA: number, iaB: number): number;
declare function lbFromLaAaAb(ila: number, iaA: number, iaB: number): number;
declare function aBFromLaLbAa(ila: number, ilb: number, iaA: number): number;

type tPolar = [number, number];
declare enum ShapePoint {
    eDefault = 0,
    eCircle = 1,
    eCross = 2,
    eSquare = 3,
    eBigSquare = 4,
    eTwoTri = 5,
    eTri1 = 6,
    eTri2 = 7,
    eTri3 = 8,
    eTri4 = 9
}
declare class Point {
    cx: number;
    cy: number;
    shape: ShapePoint;
    constructor(ix: number, iy: number, ishape?: ShapePoint);
    draw(ctx: CanvasRenderingContext2D, cAdjust: tCanvasAdjust, color?: string, ishape?: ShapePoint): void;
    distanceOrig(): number;
    angleOrig(): number;
    getPolar(): tPolar;
    setPolar(ia: number, il: number): Point;
    translate(ix: number, iy: number): Point;
    translatePolar(ia: number, il: number): Point;
    clone(ishape?: ShapePoint): Point;
    rotateOrig(ia: number): Point;
    scaleOrig(ir: number): Point;
    rotate(ic: Point, ia: number): Point;
    scale(ic: Point, ir: number): Point;
    isEqual(ic: Point): boolean;
    distanceToPoint(p2: Point): number;
    angleToPoint(p2: Point): number;
    angleFromToPoints(p2: Point, p3: Point): number;
    middlePoint(p2: Point): Point;
    equidistantPoint(p2: Point, dist: number, p3: Point): Point;
}
declare function point(ix: number, iy: number, ishape?: ShapePoint): Point;
declare function pointMinMax(aPoint: Point[]): [number, number, number, number];

interface tAffine {
    quasiVertical: boolean;
    ha: number;
    hb: number;
    va: number;
    vb: number;
}
declare class Line {
    cx: number;
    cy: number;
    ca: number;
    constructor(ix: number, iy: number, ia: number);
    draw(ctx: CanvasRenderingContext2D, cAdjust: tCanvasAdjust, color?: string): void;
    setFromPoints(p1: Point, p2: Point): this;
    getAffine(): tAffine;
    setAffine(iAffine: tAffine): Line;
    intersection(il: Line): Point;
    getAxisXIntersection(): number;
    getAxisYIntersection(): number;
    getAxisXIntersecTri(): number;
    getAxisYIntersecTri(): number;
    angleOrig(): number;
    distanceOrig(): number;
    projectOrig(): Point;
    translate(ix: number, iy: number): Line;
    rotateOrig(ia: number): Line;
    scaleOrig(ir: number): Line;
    rotate(ic: Point, ia: number): Line;
    scale(ic: Point, ir: number): Line;
    clone(): Line;
    lineOrthogonal(ic: Point): Line;
    lineParallel(ic: Point): Line;
    distanceToPoint(ic: Point): number;
    projectPoint(ic: Point): Point;
    isParallel(il: Line): boolean;
    isOrthogonal(il: Line): boolean;
    isEqual(il: Line): boolean;
    bisector(il: Line, ip: Point): Line;
    lineParallelDistance(iDist: number, ipMagnet: Point, ipMagnet2: Point): Line;
}
declare function line(ix: number, iy: number, ia: number): Line;
declare function linePP(ip1: Point, ip2: Point): Line;
declare function bisector(ip1: Point, ip2: Point): Line;
declare function circleCenter(ip1: Point, ip2: Point, ip3: Point): Point;

declare enum SegEnum {
    eStroke = 0,
    eArc = 1,
    ePointed = 2,
    eRounded = 3,
    eWidened = 4,
    eWideAcc = 5,// Widened Access
    eStart = 6
}
declare function isSeg(iSegEnum: SegEnum): boolean;
declare function isAddPoint(iSegEnum: SegEnum): boolean;
declare function isActiveCorner(iSegEnum: SegEnum): boolean;
declare function isCorner(iSegEnum: SegEnum): boolean;
declare class Segment1 {
    sType: SegEnum;
    px: number;
    py: number;
    radius: number;
    arcLarge: boolean;
    arcCcw: boolean;
    constructor(iType: SegEnum, ix: number, iy: number, iRadius: number, iArcLarge?: boolean, iArcCcw?: boolean);
    clone(): Segment1;
}
declare class Segment2 {
    sType: SegEnum;
    p1: Point;
    p2: Point;
    pc: Point;
    radius: number;
    a1: number;
    a2: number;
    arcCcw: boolean;
    constructor(iType: SegEnum, ip1: Point, ip2: Point, ipc: Point, iRadius: number, ia1: number, ia2: number, iArcCcw?: boolean);
}
declare class SegDbg {
    debugPoints: Point[];
    debugLines: Line[];
    logMessage: string;
    constructor();
    addPoint(ip: Point): void;
    getPoints(): Point[];
    clearPoints(): void;
    addLine(il: Line): void;
    getLines(): Line[];
    clearLines(): void;
    addMsg(iMsg: string): void;
    getMsg(): string;
    clearMsg(): void;
}
declare const gSegDbg: SegDbg;
declare function arcSeg1To2(px1: number, py1: number, iSeg1: Segment1): Segment2;
declare function arcSeg2To1(iSeg2: Segment2): Segment1;
declare function makeCorner(s1: Segment2, s2: Segment2, s3: Segment2): Segment2[];

type tCartesian = [number, number];
declare class Vector {
    ca: number;
    cl: number;
    drawPoint: Point;
    constructor(ia: number, il: number, iDrawPoint: Point);
    draw(ctx: CanvasRenderingContext2D, cAdjust: tCanvasAdjust, color?: string): void;
    getCartesian(): tCartesian;
    setCartesian(ix: number, iy: number): Vector;
    translatePoint(ip: Point): Point;
    add(iVect: Vector): Vector;
    addCart(ix: number, iy: number): Vector;
    translate(ix: number, iy: number): Vector;
    rotate(ic: Point, ia: number): Vector;
    clone(): Vector;
    isEqual(iVect: Vector): boolean;
    dotProduct(iVect: Vector): number;
    crossProduct(iVect: Vector): number;
}
declare function vector(ia: number, il: number, iDrawPoint: Point): Vector;

declare class DxfSeg {
    arc: boolean;
    p1x: number;
    p1y: number;
    radius: number;
    a1: number;
    a2: number;
    p2x: number;
    p2y: number;
    constructor(arc: boolean, p1x: number, p1y: number, radius: number, a1: number, a2: number, p2x: number, p2y: number);
}
declare function dxfSegLine(p1x: number, p1y: number, p2x: number, p2y: number): DxfSeg;
declare function dxfSegArc(p1x: number, p1y: number, radius: number, aa1: number, aa2: number, arcCcw: boolean): DxfSeg;
declare function dxfSegCircle(p1x: number, p1y: number, radius: number): DxfSeg;
declare class DxfWrite {
    dxfStr: string;
    constructor();
    addCircle(cx: number, cy: number, radius: number): void;
    addLine(p1x: number, p1y: number, p2x: number, p2y: number): void;
    addArc(cx: number, cy: number, ra: number, a1: number, a2: number): void;
    close(): void;
    stringify(): string;
}
declare function dxfWriter(): DxfWrite;

interface tPaxContourCircle {
    circle: boolean;
    cx: number;
    cy: number;
    radius: number;
}
declare enum PSeg {
    eStart = 0,
    eStroke = 1,
    eArc = 2
}
interface tPaxSegSt {
    typ: PSeg;
    px: number;
    py: number;
}
interface tPaxSegArc {
    typ: PSeg;
    px: number;
    py: number;
    radius: number;
    large: boolean;
    ccw: boolean;
}
type tPaxSeg = tPaxSegSt | tPaxSegArc;
interface tPaxContourPath {
    circle: boolean;
    seg: tPaxSeg[];
}
type tPaxContour = tPaxContourPath | tPaxContourCircle;
type tPaxFace = tPaxContour[];
declare function paxCircle(cx: number, cy: number, radius: number): tPaxContourCircle;
declare class PaxPath {
    seg: tPaxSeg[];
    constructor();
    addStart(px: number, py: number): void;
    addStroke(px: number, py: number): void;
    addArc(cx: number, cy: number, radius: number, large: boolean, ccw: boolean): void;
    toJson(): tPaxContourPath;
}
declare function paxPath(): PaxPath;

interface tEnvelop {
    xMin: number;
    xMax: number;
    yMin: number;
    yMax: number;
    orientation: boolean;
}
declare class Envelop {
    /** @internal */
    pEnvelop: tEnvelop;
    constructor(iEnvelop: tEnvelop);
    add(iEnvelop: tEnvelop): boolean;
    check(iEnvelop: tEnvelop): boolean;
}
declare function envelop(iEnvelop: tEnvelop): Envelop;

declare abstract class AContour {
    abstract circle: boolean;
    abstract imposedColor: string;
    abstract draw(ctx: CanvasRenderingContext2D, cAdjust: tCanvasAdjust, color: string): void;
    abstract extractSkeleton(): AContour;
    abstract generateContour(): AContour;
    abstract generatePoints(dnb: number): Point[];
    abstract getEnvelop(): tEnvelop;
    abstract generateLines(): Line[];
    abstract check(): string;
    abstract toSvg(yCeiling: number, color?: string): string;
    abstract toDxfSeg(): DxfSeg[];
    abstract toPax(): tPaxContour;
    abstract getPerimeter(): number;
    abstract generateRevertOrientation(): AContour;
}
declare function midArcPoint(px1: number, py1: number, seg: Segment1, dnb: number): Point[];
/**
 * class `Contour`
 *
 */
declare class Contour extends AContour {
    /** @internal */
    circle: boolean;
    segments: Segment1[];
    points: Point[];
    debugPoints: Point[];
    debugLines: Line[];
    lastPoint: Point;
    lastPoint2: Point;
    imposedColor: string;
    /**
     *	@param ix - the X absolute coordinate of the first point of the contour
     *	@param iy - the Y absolute coordinate of the first point of the contour
     *	@param icolor - an optional color name to be used instead of the default color
     */
    constructor(ix: number, iy: number, icolor?: string);
    /** @internal */
    setLastPoint(ix: number, iy: number): void;
    /** @internal */
    getLastPoint(): Point;
    getFirstPoint(): Point;
    addPointA(ax: number, ay: number): this;
    addPointAP(aa: number, al: number): this;
    addPointR(rx: number, ry: number): this;
    addPointRP(ra: number, rl: number): this;
    /** @internal */
    addSeg(iSeg: Segment1): this;
    /** @internal */
    addSegStroke(): this;
    addSegStrokeA(ax: number, ay: number): this;
    addSegStrokeAP(aa: number, al: number): this;
    addSegStrokeR(rx: number, ry: number): this;
    addSegStrokeRP(ra: number, rl: number): this;
    addSegArc(iRadius: number, iLarge: boolean, iCcw: boolean): this;
    addSegArc2(): this;
    addSegArc3(iTangentAngle1: number, firstNlast: boolean): this;
    addSeg2Arcs(ita1: number, ita2: number): this;
    addSegStrokeAifBig(ax: number, ay: number, minLength: number, secondNfirst: boolean): this;
    addCornerPointed(): this;
    addCornerRounded(iRadius: number): this;
    addCornerWidened(iRadius: number): this;
    addCornerWideAcc(iRadius: number): this;
    closeSegStroke(): this;
    closeSegArc(iRadius: number, iLarge: boolean, iCcw: boolean): this;
    /** @internal */
    clone(): Contour;
    translate(ix: number, iy: number): Contour;
    translatePolar(ia: number, il: number): Contour;
    rotate(ix: number, iy: number, ia: number): Contour;
    scale(ix: number, iy: number, ir: number, scaleCorner?: boolean): Contour;
    addPartial(iContour: Contour): this;
    draw(ctx: CanvasRenderingContext2D, cAdjust: tCanvasAdjust, color?: string): void;
    extractSkeleton(): Contour;
    generateContour(): Contour;
    generatePoints(dnb: number): Point[];
    getOrientation(iPts: Point[], extremX: number, theMax: boolean): boolean;
    getEnvelop(): tEnvelop;
    generateLines(): Line[];
    /** @internal */
    checkContour(ctr: Contour): void;
    check(): string;
    toSvg(yCeiling: number, color?: string): string;
    toDxfSeg(): DxfSeg[];
    toPax(): tPaxContourPath;
    getPerimeter(): number;
    generateRevertOrientation(): Contour;
}
/**
 * class `ContourCircle`
 *
 */
declare class ContourCircle extends AContour {
    circle: boolean;
    px: number;
    py: number;
    radius: number;
    imposedColor: string;
    constructor(ix: number, iy: number, iRadius: number, icolor?: string);
    /** @internal */
    clone(): ContourCircle;
    translate(ix: number, iy: number): ContourCircle;
    translatePolar(ia: number, il: number): ContourCircle;
    rotate(ix: number, iy: number, ia: number): ContourCircle;
    draw(ctx: CanvasRenderingContext2D, cAdjust: tCanvasAdjust, color?: string): void;
    extractSkeleton(): ContourCircle;
    generateContour(): ContourCircle;
    generatePoints(dnb: number): Point[];
    getEnvelop(): tEnvelop;
    generateLines(): Line[];
    check(): string;
    toSvg(yCeiling: number, color?: string): string;
    toDxfSeg(): DxfSeg[];
    toPax(): tPaxContourCircle;
    getPerimeter(): number;
    generateRevertOrientation(): ContourCircle;
}
declare function contour(ix: number, iy: number, icolor?: string): Contour;
declare function contourCircle(ix: number, iy: number, iRadius: number, icolor?: string): ContourCircle;
type tContour = Contour | ContourCircle;

interface tLayers {
    points: boolean;
    lines: boolean;
    vectors: boolean;
    main: boolean;
    mainB: boolean;
    second: boolean;
    secondB: boolean;
    dynamics: boolean;
    ruler: boolean;
    refframe: boolean;
}
/**
 * The face-type is a list of contours. The first contour is the outer, the remaining are the inner contours
 */
type tOuterInner = tContour[];
declare class Figure {
    pointList: Point[];
    lineList: Line[];
    vectorList: Vector[];
    mainList: tOuterInner[];
    mainBList: tContour[];
    secondList: tContour[];
    secondBList: tContour[];
    dynamicsList: tContour[];
    xMin: number;
    xMax: number;
    yMin: number;
    yMax: number;
    constructor();
    addPoint(ipoint: Point): void;
    addPoints(ipoints: Point[]): void;
    addLine(iline: Line): void;
    addLines(ilines: Line[]): void;
    addVector(ivector: Vector): void;
    /**
     * add one face (one Outer contour and several Inner contours) to the Main Layer
     * @param {tOuterInner} iFace - the Face (i.e one Outer and several Inner contours) to be added
     */
    addMainOI(iFace: tOuterInner): void;
    /**
     * add a simple face (one Outer contour) to the Main Layer
     * @param {tContour} iFace - the Face (without inner contours) to be added
     */
    addMainO(iFace: tContour): void;
    addSecond(icontour: tContour): void;
    addDynamics(icontour: tContour): void;
    translate(ix: number, iy: number): Figure;
    translatePolar(ia: number, il: number): Figure;
    rotate(ix: number, iy: number, ia: number): Figure;
    mergeFigure(ifig: Figure, mainToSecond?: boolean): void;
    mainListC(): tContour[];
    clear(): void;
    /** @internal */
    getMinMax(): void;
    getAdjustFull(iCanvasWidth: number, iCanvasHeight: number): tCanvasAdjust;
    getAdjustZoom(iCanvasWidth: number, iCanvasHeight: number): tCanvasAdjust;
    /** @internal */
    quantifyRuler(canvasWidth: number, adjust: tCanvasAdjust): number[];
    drawRuler(ctx: CanvasRenderingContext2D, adjust: tCanvasAdjust, color: string): void;
    draw(ctx: CanvasRenderingContext2D, adjust: tCanvasAdjust, layers: tLayers): void;
}
declare function figure(): Figure;
type tFigures = Record<string, Figure>;
/** For cli-app and ui-app */
declare function mergeFaces(iFigures: tFigures): Figure;
declare function initLayers(): tLayers;
declare function copyLayers(iLayers: tLayers): tLayers;

declare enum PType {
    eNumber = 0,
    eCheckbox = 1,
    eDropdown = 2,
    eSectionSeparator = 3
}
interface tParam {
    name: string;
    unit: string;
    init: number;
    min: number;
    max: number;
    step: number;
    dropdown: string[];
    pType: PType;
}
interface tSimTime {
    tMax: number;
    tStep: number;
    tUpdate: number;
}
interface tParamDef {
    partName: string;
    params: tParam[];
    paramSvg: Record<string, string>;
    sim: tSimTime;
}
declare const zeroPDef: tParamDef;
type tParamVal = Record<string, number>;
type tParamChanged = Record<string, boolean>;
interface tDesignParamOne {
    val: number;
    init: number;
    chg: boolean;
}
declare function oneDesignParam(iVal: number, iInit: number, iChg: boolean): tDesignParamOne;
type tDesignParamList = Record<string, tDesignParamOne>;
declare function paramListToVal(dpList: tDesignParamList): tParamVal;
declare class DesignParam {
    paramVal: tParamVal;
    paramInit: tParamVal;
    paramChanged: tParamChanged;
    partName: string;
    suffix: string;
    paramNames: string[];
    getParamName(): string[];
    constructor(iparamDef: tParamDef, suffix?: string);
    getPartName(): string;
    getPartNameSuffix(): string;
    getSuffix(): string;
    getParamVal(): tParamVal;
    getVal(iname: string): number;
    getInit(iname: string): number;
    getChanged(iname: string): boolean;
    setVal(iname: string, ival: number): void;
    applyParamVal(iValues: tParamVal): string;
    applyParamList(iValues: tDesignParamList): string;
    getDesignParamList(): tDesignParamList;
}
declare function designParam(iparamDef: tParamDef, suffix?: string): DesignParam;
declare function pNumber(name: string, unit: string, init: number, min?: number, max?: number, step?: number): tParam;
declare function pCheckbox(name: string, init: boolean): tParam;
declare function pDropdown(name: string, values: string[], iInit?: number): tParam;
declare function pSectionSeparator(name: string): tParam;

type tPosiOrien = [number, number, number];
interface tSubInst {
    partName: string;
    dparam: tDesignParamList;
    orientation: tPosiOrien;
    position: tPosiOrien;
}
type tSubDesign = Record<string, tSubInst>;

interface tGeom {
    partName: string;
    calcErr: boolean;
    logstr: string;
    fig: tFigures;
    vol: tVolume;
    sub: tSubDesign;
}
type tGeomFunc = (t: number, ipVal: tParamVal, suffix?: string) => tGeom;
interface tPageDef {
    pTitle: string;
    pDescription: string;
    pDef: tParamDef;
    pGeom: tGeomFunc;
}
type tAllPageDef = Record<string, tPageDef>;
type tAllLink = Record<string, string>;
declare function fround(ireal: number, iprecision?: number): number;
declare function initGeom(partName: string): tGeom;
declare function checkGeom(iGeom: tGeom): void;
declare function prefixLog(iLog: string, iPartName: string): string;

interface tInherit {
    outName: string;
    subdesign: string;
    subgeom: tGeom;
    rotate: [number, number, number];
    translate: [number, number, number];
}
declare enum EExtrude {
    eLinearOrtho = 0,
    eRotate = 1
}
interface tExtrude {
    outName: string;
    face: string;
    extrudeMethod: EExtrude;
    length?: number;
    rotate: [number, number, number];
    translate: [number, number, number];
}
declare enum EBVolume {
    eIdentity = 0,
    eIntersection = 1,
    eUnion = 2,
    eSubstraction = 3
}
interface tBVolume {
    outName: string;
    boolMethod: EBVolume;
    inList: string[];
}
interface tVolume {
    inherits?: tInherit[];
    extrudes: tExtrude[];
    volumes: tBVolume[];
}

declare enum EFormat {
    eSVG = 0,
    eSVGALL = 1,
    eDXF = 2,
    eDXFALL = 3,
    eTXTLOG = 4,
    ePAX = 5,
    eOPENSCAD = 6,
    eJSCAD = 7,
    eFREECAD = 8,
    eZIP = 9
}
declare function fileTextContent(fgeom: tGeomFunc, paramVal: tParamVal, ipDef: tParamDef, eFace: string, exportFormat: EFormat): string;
declare function fileBinContent(fgeom: tGeomFunc, tSim: number, paramVal: tParamVal, ipDef: tParamDef, exportFormat: EFormat): Promise<Blob>;
declare function fileMime(exportFormat: EFormat): string;
declare function fileSuffix(exportFormat: EFormat): string;
declare function fileBin(exportFormat: EFormat): boolean;

interface tParamValInFile {
    lastModif: string;
    partName: string;
    pVal: tParamVal;
    comment: string;
}
declare function createParamFile(lastModif: string, iPartName: string, idparams: tParamVal, comment: string): string;
declare function parseParamFile(fContentStr: string): [tParamValInFile, string];

type tVec2 = [number, number];
type tVec3b = [number, number, number];
type tT2dMatrix = [tVec3b, tVec3b, tVec3b];
declare class Transform2d {
    mmat: tT2dMatrix;
    constructor(iMat: tT2dMatrix);
    addRotation(az: number): this;
    addTranslation(ax: number, ay: number): this;
    getMatrix(): tT2dMatrix;
    getRotation(): number;
    getTranslation(): tVec2;
    transform(iv: tVec2): tVec2;
}
declare function transform2d(initM?: tT2dMatrix): Transform2d;

type tVec3 = [number, number, number];
type tVec4 = [number, number, number, number];
type tT3dMatrix = [tVec4, tVec4, tVec4, tVec4];
declare class Transform3d {
    mmat: tT3dMatrix;
    constructor(iMat: tT3dMatrix);
    addRotation(ax: number, ay: number, az: number): this;
    addTranslation(ax: number, ay: number, az: number): this;
    getMatrix(): tT3dMatrix;
    getRotation(): tVec3;
    getTranslation(): tVec3;
    transform(iv: tVec3): tVec3;
}
declare function transform3d(initM?: tT3dMatrix): Transform3d;

/**
 * The rectangle-origin is bottom-left.
 */
declare function ctrRectangle(ox: number, oy: number, width: number, height: number, cornerRounded?: number): tContour;
/**
 * The rectangle-origin is bottom-left.
 */
declare function ctrRectRot(ox: number, oy: number, width: number, height: number, angle: number, cornerRounded?: number): tContour;
/**
 * The rectangle-origin is middle-left.
 */
declare function ctrRectRot2(ox: number, oy: number, width: number, height: number, angle: number, cornerRounded?: number): tContour;
/**
 * The trapezoid-origin is bottom-left.
 */
declare function ctrTrapezoid(ox: number, oy: number, bottomWidth: number, topWidth: number, height: number, cornerRounded?: number): tContour;
/**
 * The trapezoid-origin is middle-left.
 */
declare function ctrTrapezoidRot2(ox: number, oy: number, leftSide: number, rightSide: number, Hlength: number, angle: number, cornerRounded?: number): tContour;
/**
 * The oblong-origin is middle-left.
 */
declare function ctrOblong(ox: number, oy: number, Vwidth: number, Hlength: number, angle: number): tContour;

/** For cli-app and ui-app */
type tDependencies = Record<string, string>;
/** For cli-app and ui-app */
interface tPackage {
    name: string;
    version: string;
    dependencies: tDependencies;
}
/** For cli-app and ui-app */
declare function version_details(appPackage: tPackage): string[];

declare function checkImpPages(pages: tAllPageDef): [boolean, string];

export { Contour, ContourCircle, DesignParam, DxfSeg, DxfWrite, EBVolume, EExtrude, EFormat, Envelop, Figure, Line, PSeg, PType, PaxPath, Point, SegDbg, SegEnum, Segment1, Segment2, ShapePoint, Transform2d, Transform3d, Vector, aBFromLaLbAa, aCFromAaAb, aCFromLaLbLc, adjustCenter, adjustCopy, adjustInit, adjustMini, adjustRect, adjustScale, adjustTranslate, adjustZero, arcSeg1To2, arcSeg2To1, bisector, canvas2point, canvasTranslatePolar, checkGeom, checkImpPages, circleCenter, colors, contour, contourCircle, copyLayers, createParamFile, ctrOblong, ctrRectRot, ctrRectRot2, ctrRectangle, ctrTrapezoid, ctrTrapezoidRot2, degToRad, designParam, dxfSegArc, dxfSegCircle, dxfSegLine, dxfWriter, envelop, ffix, figure, fileBin, fileBinContent, fileMime, fileSuffix, fileTextContent, fround, gSegDbg, initGeom, initLayers, isActiveCorner, isAddPoint, isCorner, isSeg, isWithin, lbFromLaAaAb, lcFromLaLbAc, line, linePP, makeCorner, mergeFaces, midArcPoint, oneDesignParam, orientedArc, pCheckbox, pDropdown, pNumber, pSectionSeparator, paramListToVal, parseParamFile, paxCircle, paxPath, point, point2canvas, pointCoord, pointMinMax, prefixLog, radToDeg, radius2canvas, rightTriLaFromLbLc, rightTriLbFromLaLc, roundZero, type tAffine, type tAllLink, type tAllPageDef, type tBVolume, type tCanvasAdjust, type tCartesian, type tContour, type tDependencies, type tDesignParamList, type tDesignParamOne, type tEnvelop, type tExtrude, type tFigures, type tGeom, type tGeomFunc, type tInherit, type tLayers, type tOuterInner, type tPackage, type tPageDef, type tParam, type tParamChanged, type tParamDef, type tParamVal, type tParamValInFile, type tPaxContour, type tPaxContourCircle, type tPaxContourPath, type tPaxFace, type tPaxSeg, type tPaxSegArc, type tPaxSegSt, type tPolar, type tPosiOrien, type tSimTime, type tSubDesign, type tSubInst, type tT2dMatrix, type tT3dMatrix, type tVec2, type tVec3, type tVec3b, type tVec4, type tVolume, tolerance, transform2d, transform3d, vector, version_details, withinHPiHPi, withinPiPi, withinZero2Pi, withinZeroPi, zeroPDef };