@duet3d/objectmodel 3.7.0-alpha.6 → 3.7.0-alpha.7

package/dist/src/move/index.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Move = exports.MoveRotation = exports.MoveQueueItem = exports.MotorsIdleControl = exports.CurrentMove = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const ModelCollection_1 = __importDefault(require("../ModelCollection"));
+const Axis_1 = __importDefault(require("./Axis"));
+const Extruder_1 = __importDefault(require("./Extruder"));
+const InputShaping_1 = __importDefault(require("./InputShaping"));
+const KeepoutZone_1 = __importDefault(require("./KeepoutZone"));
+const MotionSystem_1 = __importDefault(require("./MotionSystem"));
+const MoveCalibration_1 = __importDefault(require("./MoveCalibration"));
+const MoveCompensation_1 = __importDefault(require("./MoveCompensation"));
+const kinematics_1 = require("./kinematics");
+class CurrentMove extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.acceleration = 0;
+        this.deceleration = 0;
+        this.extrusionRate = 0;
+        this.laserPwm = null;
+        this.requestedSpeed = 0;
+        this.topSpeed = 0;
+    }
+}
+exports.CurrentMove = CurrentMove;
+class MotorsIdleControl extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.factor = 0.3;
+        this.timeout = 30;
+    }
+}
+exports.MotorsIdleControl = MotorsIdleControl;
+class MoveQueueItem extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.gracePeriod = 0;
+        this.length = 0;
+    }
+}
+exports.MoveQueueItem = MoveQueueItem;
+class MoveRotation extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.angle = 0;
+        this.centre = [0, 0];
+    }
+}
+exports.MoveRotation = MoveRotation;
+class Move extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.accelerationTime = null;
+        this.axes = new ModelCollection_1.default(Axis_1.default);
+        this.backlashFactor = 10;
+        this.calibration = new MoveCalibration_1.default();
+        this.compensation = new MoveCompensation_1.default();
+        this.currentMove = new CurrentMove();
+        this.extruders = new ModelCollection_1.default(Extruder_1.default);
+        this.idle = new MotorsIdleControl();
+        this.keepout = new ModelCollection_1.default(KeepoutZone_1.default);
+        this.kinematics = new kinematics_1.CoreKinematics(kinematics_1.KinematicsName.cartesian);
+        this.limitAxes = true;
+        this.noMovesBeforeHoming = true;
+        this.motionSystems = new ModelCollection_1.default(MotionSystem_1.default);
+        /**
+         * @deprecated use motionSystems[].printingAcceleration instead
+         */
+        this.printingAcceleration = 10000;
+        this.queue = new ModelCollection_1.default(MoveQueueItem);
+        /**
+         * @deprecated use motionSystems[].rotation instead
+         */
+        this.rotation = new MoveRotation();
+        this.shaping = new InputShaping_1.default();
+        this.speedFactor = 1;
+        /**
+         * @deprecated use motionSystems[].travelAcceleration instead
+         */
+        this.travelAcceleration = 10000;
+        this.usingSCurve = false;
+        /**
+         * @deprecated use motionSystems[].virtualEPos instead
+         */
+        this.virtualEPos = 0;
+        /**
+         * @deprecated use motionSystems[].workplaceNumber instead
+         */
+        this.workplaceNumber = 0;
+    }
+}
+exports.Move = Move;
+exports.default = Move;
+__exportStar(require("./kinematics"), exports);
+__exportStar(require("./Axis"), exports);
+__exportStar(require("./DriverId"), exports);
+__exportStar(require("./Extruder"), exports);
+__exportStar(require("./InputShaping"), exports);
+__exportStar(require("./KeepoutZone"), exports);
+__exportStar(require("./Microstepping"), exports);
+__exportStar(require("./MoveCalibration"), exports);
+__exportStar(require("./MotionSystem"), exports);
+__exportStar(require("./MoveCompensation"), exports);

package/dist/src/move/kinematics/CoreKinematics.d.ts

@@ -0,0 +1,9 @@
+import { IModelObject } from "../../ModelObject";
+import { KinematicsName, ZLeadscrewKinematics } from "./KinematicsBase";
+export declare class CoreKinematics extends ZLeadscrewKinematics {
+    constructor(name: KinematicsName);
+    forwardMatrix: Array<Array<number>>;
+    inverseMatrix: Array<Array<number>>;
+    update(jsonElement: any): IModelObject | null;
+}
+export default CoreKinematics;

package/dist/src/move/kinematics/CoreKinematics.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class CoreKinematics extends KinematicsBase_1.ZLeadscrewKinematics {
+    constructor(name) {
+        super(name);
+        this.forwardMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+        this.inverseMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.CoreKinematics = CoreKinematics;
+exports.default = CoreKinematics;

package/dist/src/move/kinematics/DeltaKinematics.d.ts

@@ -0,0 +1,20 @@
+import ModelCollection from "../../ModelCollection";
+import ModelObject, { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export declare class DeltaTower extends ModelObject {
+    angleCorrection: number;
+    diagonal: number;
+    endstopAdjustment: number;
+    xPos: number;
+    yPos: number;
+}
+export declare class DeltaKinematics extends KinematicsBase {
+    deltaRadius: number;
+    homedHeight: number;
+    printRadius: number;
+    readonly towers: ModelCollection<DeltaTower>;
+    xTilt: number;
+    yTilt: number;
+    update(jsonElement: any): IModelObject | null;
+}
+export default DeltaKinematics;

package/dist/src/move/kinematics/DeltaKinematics.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaKinematics = exports.DeltaTower = void 0;
+const ModelCollection_1 = require("../../ModelCollection");
+const ModelObject_1 = __importDefault(require("../../ModelObject"));
+const KinematicsBase_1 = __importDefault(require("./KinematicsBase"));
+const index_1 = require("./index");
+class DeltaTower extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.angleCorrection = 0;
+        this.diagonal = 0;
+        this.endstopAdjustment = 0;
+        this.xPos = 0;
+        this.yPos = 0;
+    }
+}
+exports.DeltaTower = DeltaTower;
+class DeltaKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(...arguments);
+        this.deltaRadius = 0;
+        this.homedHeight = 0;
+        this.printRadius = 0;
+        this.towers = (0, ModelCollection_1.initCollection)(DeltaTower, [{}, {}, {}]);
+        this.xTilt = 0;
+        this.yTilt = 0;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.DeltaKinematics = DeltaKinematics;
+exports.default = DeltaKinematics;

package/dist/src/move/kinematics/HangprinterKinematics.d.ts

@@ -0,0 +1,9 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export declare class HangprinterKinematics extends KinematicsBase {
+    anchors: Array<Array<number>>;
+    printRadius: number;
+    constructor();
+    update(jsonElement: any): IModelObject | null;
+}
+export default HangprinterKinematics;

package/dist/src/move/kinematics/HangprinterKinematics.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HangprinterKinematics = void 0;
+const KinematicsBase_1 = __importStar(require("./KinematicsBase"));
+const index_1 = require("./index");
+class HangprinterKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(KinematicsBase_1.KinematicsName.hangprinter);
+        this.anchors = [
+            [0, -2000, -100],
+            [2000, 1000, -100],
+            [-2000, 1000, -100],
+            [0, 0, 3000]
+        ];
+        this.printRadius = 1500;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.HangprinterKinematics = HangprinterKinematics;
+exports.default = HangprinterKinematics;

package/dist/src/move/kinematics/KinematicsBase.d.ts

@@ -0,0 +1,37 @@
+import ModelObject from "../../ModelObject";
+export declare enum KinematicsName {
+    cartesian = "cartesian",
+    coreXY = "coreXY",
+    coreXYU = "coreXYU",
+    coreXYUV = "coreXYUV",
+    coreXZ = "coreXZ",
+    markForged = "markForged",
+    fiveBarScara = "fiveBarScara",
+    hangprinter = "hangprinter",
+    linearDelta = "linearDelta",
+    polar = "polar",
+    rotaryDelta = "rotaryDelta",
+    scara = "scara",
+    unknown = "unknown"
+}
+export declare class MoveSegmentation extends ModelObject {
+    segmentsPerSec: number;
+    minSegmentLength: number;
+}
+export declare abstract class KinematicsBase extends ModelObject {
+    readonly name: KinematicsName;
+    readonly segmentation: MoveSegmentation;
+    constructor(name: KinematicsName);
+}
+export default KinematicsBase;
+export declare class TiltCorrection extends ModelObject {
+    correctionFactor: number;
+    lastCorrections: Array<number>;
+    maxCorrection: number;
+    screwPitch: number;
+    screwX: Array<number>;
+    screwY: Array<number>;
+}
+export declare abstract class ZLeadscrewKinematics extends KinematicsBase {
+    readonly tiltCorrection: TiltCorrection;
+}

package/dist/src/move/kinematics/KinematicsBase.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLeadscrewKinematics = exports.TiltCorrection = exports.KinematicsBase = exports.MoveSegmentation = exports.KinematicsName = void 0;
+const ModelObject_1 = __importDefault(require("../../ModelObject"));
+var KinematicsName;
+(function (KinematicsName) {
+    KinematicsName["cartesian"] = "cartesian";
+    KinematicsName["coreXY"] = "coreXY";
+    KinematicsName["coreXYU"] = "coreXYU";
+    KinematicsName["coreXYUV"] = "coreXYUV";
+    KinematicsName["coreXZ"] = "coreXZ";
+    KinematicsName["markForged"] = "markForged";
+    KinematicsName["fiveBarScara"] = "fiveBarScara";
+    KinematicsName["hangprinter"] = "hangprinter";
+    KinematicsName["linearDelta"] = "linearDelta";
+    KinematicsName["polar"] = "polar";
+    KinematicsName["rotaryDelta"] = "rotaryDelta";
+    KinematicsName["scara"] = "scara";
+    KinematicsName["unknown"] = "unknown";
+})(KinematicsName || (exports.KinematicsName = KinematicsName = {}));
+class MoveSegmentation extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.segmentsPerSec = 0;
+        this.minSegmentLength = 0;
+    }
+}
+exports.MoveSegmentation = MoveSegmentation;
+class KinematicsBase extends ModelObject_1.default {
+    constructor(name) {
+        super();
+        this.segmentation = new MoveSegmentation();
+        this.name = name;
+    }
+}
+exports.KinematicsBase = KinematicsBase;
+exports.default = KinematicsBase;
+class TiltCorrection extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.correctionFactor = 0;
+        this.lastCorrections = [];
+        this.maxCorrection = 0;
+        this.screwPitch = 0;
+        this.screwX = [];
+        this.screwY = [];
+    }
+}
+exports.TiltCorrection = TiltCorrection;
+class ZLeadscrewKinematics extends KinematicsBase {
+    constructor() {
+        super(...arguments);
+        this.tiltCorrection = new TiltCorrection();
+    }
+}
+exports.ZLeadscrewKinematics = ZLeadscrewKinematics;

package/dist/src/move/kinematics/PolarKinematics.d.ts

@@ -0,0 +1,12 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export declare class PolarKinematics extends KinematicsBase {
+    constructor();
+    radiusHomed: number;
+    radiusMax: number;
+    radiusMin: number;
+    ttAccMax: number;
+    ttSpeedMax: number;
+    update(jsonElement: any): IModelObject | null;
+}
+export default PolarKinematics;

package/dist/src/move/kinematics/PolarKinematics.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarKinematics = void 0;
+const KinematicsBase_1 = __importStar(require("./KinematicsBase"));
+const index_1 = require("./index");
+class PolarKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(KinematicsBase_1.KinematicsName.polar);
+        this.radiusHomed = 0;
+        this.radiusMax = 0;
+        this.radiusMin = 0;
+        this.ttAccMax = 0;
+        this.ttSpeedMax = 0;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.PolarKinematics = PolarKinematics;
+exports.default = PolarKinematics;

package/dist/src/move/kinematics/ScaraKinematics.d.ts

@@ -0,0 +1,14 @@
+import { IModelObject } from "../../ModelObject";
+import { ZLeadscrewKinematics } from "./KinematicsBase";
+export declare class ScaraKinematics extends ZLeadscrewKinematics {
+    crosstalk: number[];
+    distalLength: number;
+    minRadius: number;
+    proximalLength: number;
+    psiLimits: number[];
+    thetaLimits: number[];
+    xOffset: number;
+    yOffset: number;
+    update(jsonElement: any): IModelObject | null;
+}
+export default ScaraKinematics;

package/dist/src/move/kinematics/ScaraKinematics.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaraKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class ScaraKinematics extends KinematicsBase_1.ZLeadscrewKinematics {
+    constructor() {
+        super(...arguments);
+        this.crosstalk = [0, 0, 0];
+        this.distalLength = 0;
+        this.minRadius = 0;
+        this.proximalLength = 0;
+        this.psiLimits = [0, 0];
+        this.thetaLimits = [0, 0];
+        this.xOffset = 0;
+        this.yOffset = 0;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.ScaraKinematics = ScaraKinematics;
+exports.default = ScaraKinematics;

package/dist/src/move/kinematics/index.d.ts

@@ -0,0 +1,14 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase, { KinematicsName } from "./KinematicsBase";
+export declare class Kinematics extends KinematicsBase {
+    constructor(name?: KinematicsName);
+    update(jsonElement: any): IModelObject | null;
+}
+export default Kinematics;
+export declare function getKinematics(name: KinematicsName): KinematicsBase;
+export * from "./CoreKinematics";
+export * from "./DeltaKinematics";
+export * from "./HangprinterKinematics";
+export * from "./KinematicsBase";
+export * from "./PolarKinematics";
+export * from "./ScaraKinematics";

package/dist/src/move/kinematics/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kinematics = void 0;
+exports.getKinematics = getKinematics;
+const KinematicsBase_1 = __importStar(require("./KinematicsBase"));
+const CoreKinematics_1 = __importDefault(require("./CoreKinematics"));
+const DeltaKinematics_1 = __importDefault(require("./DeltaKinematics"));
+const HangprinterKinematics_1 = __importDefault(require("./HangprinterKinematics"));
+const ScaraKinematics_1 = __importDefault(require("./ScaraKinematics"));
+const PolarKinematics_1 = __importDefault(require("./PolarKinematics"));
+class Kinematics extends KinematicsBase_1.default {
+    constructor(name = KinematicsBase_1.KinematicsName.cartesian) {
+        super(name);
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return getKinematics(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.Kinematics = Kinematics;
+exports.default = Kinematics;
+function getKinematics(name) {
+    switch (name) {
+        case KinematicsBase_1.KinematicsName.cartesian:
+        case KinematicsBase_1.KinematicsName.coreXY:
+        case KinematicsBase_1.KinematicsName.coreXYU:
+        case KinematicsBase_1.KinematicsName.coreXYUV:
+        case KinematicsBase_1.KinematicsName.coreXZ:
+        case KinematicsBase_1.KinematicsName.markForged:
+            return new CoreKinematics_1.default(name);
+        case KinematicsBase_1.KinematicsName.linearDelta:
+            return new DeltaKinematics_1.default(name);
+        case KinematicsBase_1.KinematicsName.rotaryDelta:
+            return new Kinematics(name);
+        case KinematicsBase_1.KinematicsName.hangprinter:
+            return new HangprinterKinematics_1.default();
+        case KinematicsBase_1.KinematicsName.fiveBarScara:
+        case KinematicsBase_1.KinematicsName.scara:
+            return new ScaraKinematics_1.default(name);
+        case KinematicsBase_1.KinematicsName.polar:
+            return new PolarKinematics_1.default();
+        default:
+            const _exhaustiveCheck = name;
+        case KinematicsBase_1.KinematicsName.unknown:
+            console.warn(`Kinematics '${name}' is not supported, falling back to cartesian`);
+            return new CoreKinematics_1.default(name);
+    }
+}
+__exportStar(require("./CoreKinematics"), exports);
+__exportStar(require("./DeltaKinematics"), exports);
+__exportStar(require("./HangprinterKinematics"), exports);
+__exportStar(require("./KinematicsBase"), exports);
+__exportStar(require("./PolarKinematics"), exports);
+__exportStar(require("./ScaraKinematics"), exports);

package/dist/src/network/NetworkInterface.d.ts

@@ -0,0 +1,46 @@
+import ModelObject from "../ModelObject";
+import ModelSet from "../ModelSet";
+export declare enum NetworkProtocol {
+    HTTP = "http",
+    HTTPS = "https",
+    FTP = "ftp",
+    SFTP = "sftp",
+    Telnet = "telnet",
+    SSH = "ssh"
+}
+export declare enum NetworkInterfaceState {
+    disabled = "disabled",
+    enabled = "enabled",
+    starting1 = "starting1",
+    starting2 = "starting2",
+    changingMode = "changingMode",
+    establishingLink = "establishingLink",
+    obtainingIP = "obtainingIP",
+    connected = "connected",
+    active = "active",
+    idle = "idle"
+}
+export declare enum NetworkInterfaceType {
+    ethernet = "ethernet",
+    wifi = "wifi"
+}
+export declare class NetworkInterface extends ModelObject {
+    activeProtocols: ModelSet<NetworkProtocol>;
+    actualIP: string | null;
+    configuredIP: string | null;
+    dnsServer: string | null;
+    firmwareVersion: string | null;
+    gateway: string | null;
+    mac: string | null;
+    numReconnects: number | null;
+    rssi: number | null;
+    /** @deprecated use rssi instead */
+    signal: number | null;
+    speed: number | null;
+    ssid: string | null;
+    state: NetworkInterfaceState | null;
+    subnet: string | null;
+    type: NetworkInterfaceType;
+    wifiCountry: string | null;
+}
+export default NetworkInterface;