@duet3d/objectmodel 3.4.0

package/lib/move/kinematics/KinematicsBase.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLeadscrewKinematics = exports.TiltCorrection = exports.MoveSegmentation = exports.KinematicsName = void 0;
+const ModelObject_1 = 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["delta"] = "delta";
+    KinematicsName["polar"] = "polar";
+    KinematicsName["rotaryDelta"] = "rotary delta";
+    KinematicsName["scara"] = "scara";
+    KinematicsName["unknown"] = "unknown";
+})(KinematicsName = exports.KinematicsName || (exports.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.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/lib/move/kinematics/PolarKinematics.d.ts

@@ -0,0 +1,6 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export default class PolarKinematics extends KinematicsBase {
+    constructor();
+    update(jsonElement: any): IModelObject | null;
+}

package/lib/move/kinematics/PolarKinematics.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class PolarKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(KinematicsBase_1.KinematicsName.polar);
+    }
+    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.default = PolarKinematics;

package/lib/move/kinematics/ScaraKinematics.d.ts

@@ -0,0 +1,5 @@
+import { IModelObject } from "../../ModelObject";
+import { ZLeadscrewKinematics } from "./KinematicsBase";
+export default class ScaraKinematics extends ZLeadscrewKinematics {
+    update(jsonElement: any): IModelObject | null;
+}

package/lib/move/kinematics/ScaraKinematics.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class ScaraKinematics extends KinematicsBase_1.ZLeadscrewKinematics {
+    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.default = ScaraKinematics;

package/lib/move/kinematics/index.d.ts

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

package/lib/move/kinematics/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const CoreKinematics_1 = require("./CoreKinematics");
+const DeltaKinematics_1 = require("./DeltaKinematics");
+const HangprinterKinematics_1 = require("./HangprinterKinematics");
+const ScaraKinematics_1 = require("./ScaraKinematics");
+const PolarKinematics_1 = require("./PolarKinematics");
+class Kinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(KinematicsBase_1.KinematicsName.unknown);
+    }
+    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.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.delta:
+        case KinematicsBase_1.KinematicsName.rotaryDelta:
+            return new DeltaKinematics_1.default(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:
+            return name;
+    }
+}
+exports.getKinematics = getKinematics;

package/lib/network/NetworkInterface.d.ts

@@ -0,0 +1,27 @@
+import ModelObject from "../ModelObject";
+export declare enum NetworkProtocol {
+    HTTP = "http",
+    HTTPS = "https",
+    FTP = "ftp",
+    SFTP = "sftp",
+    Telnet = "telnet",
+    SSH = "ssh"
+}
+export declare enum NetworkInterfaceType {
+    lan = "lan",
+    wifi = "wifi"
+}
+export default class NetworkInterface extends ModelObject {
+    activeProtocols: Set<NetworkProtocol>;
+    actualIP: string | null;
+    configuredIP: string | null;
+    dnsServer: string | null;
+    firmwareVersion: string | null;
+    gateway: string | null;
+    mac: string | null;
+    numReconnects: number | null;
+    signal: number | null;
+    speed: number | null;
+    subnet: string | null;
+    type: NetworkInterfaceType;
+}

package/lib/network/NetworkInterface.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkInterfaceType = exports.NetworkProtocol = void 0;
+const ModelObject_1 = require("../ModelObject");
+var NetworkProtocol;
+(function (NetworkProtocol) {
+    NetworkProtocol["HTTP"] = "http";
+    NetworkProtocol["HTTPS"] = "https";
+    NetworkProtocol["FTP"] = "ftp";
+    NetworkProtocol["SFTP"] = "sftp";
+    NetworkProtocol["Telnet"] = "telnet";
+    NetworkProtocol["SSH"] = "ssh";
+})(NetworkProtocol = exports.NetworkProtocol || (exports.NetworkProtocol = {}));
+var NetworkInterfaceType;
+(function (NetworkInterfaceType) {
+    NetworkInterfaceType["lan"] = "lan";
+    NetworkInterfaceType["wifi"] = "wifi";
+})(NetworkInterfaceType = exports.NetworkInterfaceType || (exports.NetworkInterfaceType = {}));
+class NetworkInterface extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.activeProtocols = new Set();
+        this.actualIP = null;
+        this.configuredIP = null;
+        this.dnsServer = null;
+        this.firmwareVersion = null;
+        this.gateway = null;
+        this.mac = null;
+        this.numReconnects = null;
+        this.signal = null;
+        this.speed = null;
+        this.subnet = null;
+        this.type = NetworkInterfaceType.wifi;
+    }
+}
+exports.default = NetworkInterface;

package/lib/network/index.d.ts

@@ -0,0 +1,12 @@
+import ModelObject from "../ModelObject";
+import ModelCollection from "../ModelCollection";
+import NetworkInterface from "./NetworkInterface";
+export declare const DefaultName = "My Duet";
+export declare const DefaultHostname = "duet";
+export declare const DefaultPassword = "reprap";
+export default class Network extends ModelObject {
+    corsSite: string | null;
+    hostname: string;
+    readonly interfaces: ModelCollection<NetworkInterface>;
+    name: string;
+}

package/lib/network/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultPassword = exports.DefaultHostname = exports.DefaultName = void 0;
+const ModelObject_1 = require("../ModelObject");
+const ModelCollection_1 = require("../ModelCollection");
+const NetworkInterface_1 = require("./NetworkInterface");
+exports.DefaultName = "My Duet";
+exports.DefaultHostname = "duet";
+exports.DefaultPassword = "reprap";
+class Network extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.corsSite = null;
+        this.hostname = exports.DefaultHostname;
+        this.interfaces = new ModelCollection_1.default(NetworkInterface_1.default);
+        this.name = exports.DefaultName;
+    }
+}
+exports.default = Network;

package/lib/plugins/PluginManifest.d.ts

@@ -0,0 +1,59 @@
+import ModelObject from "../ModelObject";
+export declare enum SbcPermission {
+    none = "none",
+    commandExecution = "commandExecution",
+    codeInterceptionRead = "codeInterceptionRead",
+    codeInterceptionReadWrite = "codeInterceptionReadWrite",
+    managePlugins = "managePlugins",
+    servicePlugins = "servicePlugins",
+    manageUserSessions = "manageUserSessions",
+    objectModelRead = "objectModelRead",
+    objectModelReadWrite = "objectModelReadWrite",
+    registerHttpEndpoints = "registerHttpEndpoints",
+    readFilaments = "readFilaments",
+    writeFilaments = "writeFilaments",
+    readFirmware = "readFirmware",
+    writeFirmware = "writeFilaments",
+    readGCodes = "readGCodes",
+    writeGCodes = "writeGCodes",
+    readMacros = "readMacros",
+    writeMacros = "writeMacros",
+    readMenu = "readMenu",
+    writeMenu = "writeMenu",
+    readSystem = "readSystem",
+    writeSystem = "writeSystem",
+    readWeb = "readWeb",
+    writeWeb = "writeWeb",
+    fileSystemAccess = "fileSystemAccess",
+    launchProcesses = "launchProcesses",
+    networkAccess = "networkAccess",
+    webcamAccess = "webcamAccess",
+    gpioAccess = "gpioAccess",
+    superUser = "superUser"
+}
+export default class PluginManifest extends ModelObject {
+    #private;
+    get id(): string;
+    set id(value: string);
+    get name(): string;
+    set name(value: string);
+    author: string;
+    version: string;
+    license: string;
+    homepage: string | null;
+    dwcVersion: string | null;
+    dwcDependencies: Array<string>;
+    sbcRequired: boolean;
+    sbcDsfVersion: string | null;
+    sbcExecutable: string | null;
+    sbcExecutableArguments: string | null;
+    sbcExtraExecutables: Array<string>;
+    sbcOutputRedirected: boolean;
+    sbcPermissions: Set<SbcPermission>;
+    sbcPackageDependencies: Array<string>;
+    sbcPluginDependencies: Array<string>;
+    sbcPythonDependencies: Array<string>;
+    rrfVersion: string | null;
+    data: Map<string, any>;
+    static checkVersion(actual: string, required: string): boolean;
+}

package/lib/plugins/PluginManifest.js

@@ -0,0 +1,112 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _PluginManifest_id, _PluginManifest_name;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SbcPermission = void 0;
+const ModelObject_1 = require("../ModelObject");
+var SbcPermission;
+(function (SbcPermission) {
+    SbcPermission["none"] = "none";
+    SbcPermission["commandExecution"] = "commandExecution";
+    SbcPermission["codeInterceptionRead"] = "codeInterceptionRead";
+    SbcPermission["codeInterceptionReadWrite"] = "codeInterceptionReadWrite";
+    SbcPermission["managePlugins"] = "managePlugins";
+    SbcPermission["servicePlugins"] = "servicePlugins";
+    SbcPermission["manageUserSessions"] = "manageUserSessions";
+    SbcPermission["objectModelRead"] = "objectModelRead";
+    SbcPermission["objectModelReadWrite"] = "objectModelReadWrite";
+    SbcPermission["registerHttpEndpoints"] = "registerHttpEndpoints";
+    SbcPermission["readFilaments"] = "readFilaments";
+    SbcPermission["writeFilaments"] = "writeFilaments";
+    SbcPermission["readFirmware"] = "readFirmware";
+    SbcPermission["writeFirmware"] = "writeFilaments";
+    SbcPermission["readGCodes"] = "readGCodes";
+    SbcPermission["writeGCodes"] = "writeGCodes";
+    SbcPermission["readMacros"] = "readMacros";
+    SbcPermission["writeMacros"] = "writeMacros";
+    SbcPermission["readMenu"] = "readMenu";
+    SbcPermission["writeMenu"] = "writeMenu";
+    SbcPermission["readSystem"] = "readSystem";
+    SbcPermission["writeSystem"] = "writeSystem";
+    SbcPermission["readWeb"] = "readWeb";
+    SbcPermission["writeWeb"] = "writeWeb";
+    SbcPermission["fileSystemAccess"] = "fileSystemAccess";
+    SbcPermission["launchProcesses"] = "launchProcesses";
+    SbcPermission["networkAccess"] = "networkAccess";
+    SbcPermission["webcamAccess"] = "webcamAccess";
+    SbcPermission["gpioAccess"] = "gpioAccess";
+    SbcPermission["superUser"] = "superUser";
+})(SbcPermission = exports.SbcPermission || (exports.SbcPermission = {}));
+class PluginManifest extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        _PluginManifest_id.set(this, "");
+        _PluginManifest_name.set(this, "");
+        this.author = "";
+        this.version = "1.0.0";
+        this.license = "LGPL-3.0-or-later";
+        this.homepage = null;
+        this.dwcVersion = null;
+        this.dwcDependencies = [];
+        this.sbcRequired = false;
+        this.sbcDsfVersion = null;
+        this.sbcExecutable = null;
+        this.sbcExecutableArguments = null;
+        this.sbcExtraExecutables = [];
+        this.sbcOutputRedirected = true;
+        this.sbcPermissions = new Set();
+        this.sbcPackageDependencies = [];
+        this.sbcPluginDependencies = [];
+        this.sbcPythonDependencies = [];
+        this.rrfVersion = null;
+        this.data = new Map();
+    }
+    get id() { return __classPrivateFieldGet(this, _PluginManifest_id, "f"); }
+    set id(value) {
+        if (!value || value.length > 32) {
+            throw new Error("Invalid plugin identifier");
+        }
+        for (const c in value.split("")) {
+            if (!/\w/.test(c)) {
+                throw new Error("Illegal plugin identifier");
+            }
+        }
+        __classPrivateFieldSet(this, _PluginManifest_id, value, "f");
+    }
+    get name() { return __classPrivateFieldGet(this, _PluginManifest_name, "f"); }
+    set name(value) {
+        if (!value || value.length > 64) {
+            throw new Error("Invalid plugin name");
+        }
+        for (const c in value.split("")) {
+            if (!/[\w -_]/.test(c)) {
+                throw new Error("Illegal plugin name");
+            }
+        }
+        __classPrivateFieldSet(this, _PluginManifest_name, value, "f");
+    }
+    static checkVersion(actual, required) {
+        if (required) {
+            const actualItems = actual.split(/[.\-+]/);
+            const requiredItems = required.split(/[.\-+]/);
+            for (let i = 0; i < Math.min(actualItems.length, requiredItems.length); i++) {
+                if (actualItems[i] !== requiredItems[i]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+exports.default = PluginManifest;
+_PluginManifest_id = new WeakMap(), _PluginManifest_name = new WeakMap();

package/lib/plugins/index.d.ts

@@ -0,0 +1,7 @@
+import PluginManifest from "./PluginManifest";
+export default class Plugin extends PluginManifest {
+    dsfFiles: Array<string>;
+    dwcFiles: Array<string>;
+    sdFiles: Array<string>;
+    pid: number;
+}

package/lib/plugins/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PluginManifest_1 = require("./PluginManifest");
+class Plugin extends PluginManifest_1.default {
+    constructor() {
+        super(...arguments);
+        this.dsfFiles = [];
+        this.dwcFiles = [];
+        this.sdFiles = [];
+        this.pid = -1;
+    }
+}
+exports.default = Plugin;

package/lib/scanner/index.d.ts

@@ -0,0 +1,13 @@
+import ModelObject from "../ModelObject";
+export declare enum ScannerStatus {
+    disconnected = "D",
+    idle = "I",
+    scanning = "S",
+    postProcessing = "P",
+    calibrating = "C",
+    uploading = "U"
+}
+export default class Scanner extends ModelObject {
+    progress: number;
+    status: ScannerStatus;
+}

package/lib/scanner/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScannerStatus = void 0;
+const ModelObject_1 = require("../ModelObject");
+var ScannerStatus;
+(function (ScannerStatus) {
+    ScannerStatus["disconnected"] = "D";
+    ScannerStatus["idle"] = "I";
+    ScannerStatus["scanning"] = "S";
+    ScannerStatus["postProcessing"] = "P";
+    ScannerStatus["calibrating"] = "C";
+    ScannerStatus["uploading"] = "U";
+})(ScannerStatus = exports.ScannerStatus || (exports.ScannerStatus = {}));
+class Scanner extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.progress = 0;
+        this.status = ScannerStatus.disconnected;
+    }
+}
+exports.default = Scanner;

package/lib/sensors/AnalogSensor.d.ts

@@ -0,0 +1,23 @@
+import ModelObject from "../ModelObject";
+export declare enum AnalogSensorType {
+    thermistor = "thermistor",
+    pt1000 = "pt1000",
+    max31865 = "rtdmax31865",
+    max31855 = "thermocouplemax31855",
+    max31856 = "thermocouplemax31856",
+    linearAnalog = "linearanalog",
+    dht11 = "dht11",
+    dht21 = "dht21",
+    dht22 = "dht22",
+    dhtHumidity = "dhthumidity",
+    currentLoop = "currentloooppyro",
+    mcuTemp = "mcutemp",
+    drivers = "drivers",
+    driversDuex = "driversduex",
+    unknown = "unknown"
+}
+export default class AnalogSensor extends ModelObject {
+    lastReading: number | null;
+    name: string | null;
+    type: AnalogSensorType;
+}

package/lib/sensors/AnalogSensor.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalogSensorType = void 0;
+const ModelObject_1 = require("../ModelObject");
+var AnalogSensorType;
+(function (AnalogSensorType) {
+    AnalogSensorType["thermistor"] = "thermistor";
+    AnalogSensorType["pt1000"] = "pt1000";
+    AnalogSensorType["max31865"] = "rtdmax31865";
+    AnalogSensorType["max31855"] = "thermocouplemax31855";
+    AnalogSensorType["max31856"] = "thermocouplemax31856";
+    AnalogSensorType["linearAnalog"] = "linearanalog";
+    AnalogSensorType["dht11"] = "dht11";
+    AnalogSensorType["dht21"] = "dht21";
+    AnalogSensorType["dht22"] = "dht22";
+    AnalogSensorType["dhtHumidity"] = "dhthumidity";
+    AnalogSensorType["currentLoop"] = "currentloooppyro";
+    AnalogSensorType["mcuTemp"] = "mcutemp";
+    AnalogSensorType["drivers"] = "drivers";
+    AnalogSensorType["driversDuex"] = "driversduex";
+    AnalogSensorType["unknown"] = "unknown";
+})(AnalogSensorType = exports.AnalogSensorType || (exports.AnalogSensorType = {}));
+class AnalogSensor extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.lastReading = null;
+        this.name = null;
+        this.type = AnalogSensorType.unknown;
+    }
+}
+exports.default = AnalogSensor;

package/lib/sensors/Endstop.d.ts

@@ -0,0 +1,13 @@
+import ModelObject from "../ModelObject";
+export declare enum EndstopType {
+    InputPin = "inputPin",
+    ZProbeAsEndstop = "zProbeAsEndstop",
+    motorStallAny = "motorStallAny",
+    motorStallIndividual = "motorStallIndividual",
+    unknown = "unknown"
+}
+export default class Endstop extends ModelObject {
+    highEnd: boolean;
+    triggered: boolean;
+    type: EndstopType;
+}

package/lib/sensors/Endstop.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndstopType = void 0;
+const ModelObject_1 = require("../ModelObject");
+var EndstopType;
+(function (EndstopType) {
+    EndstopType["InputPin"] = "inputPin";
+    EndstopType["ZProbeAsEndstop"] = "zProbeAsEndstop";
+    EndstopType["motorStallAny"] = "motorStallAny";
+    EndstopType["motorStallIndividual"] = "motorStallIndividual";
+    EndstopType["unknown"] = "unknown";
+})(EndstopType = exports.EndstopType || (exports.EndstopType = {}));
+class Endstop extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.highEnd = false;
+        this.triggered = false;
+        this.type = EndstopType.unknown;
+    }
+}
+exports.default = Endstop;

package/lib/sensors/FilamentMonitors/FilamentMonitorBase.d.ts

@@ -0,0 +1,23 @@
+import ModelObject from "../../ModelObject";
+export declare enum FilamentMonitorStatus {
+    noMonitor = "noMonitor",
+    ok = "ok",
+    noDataReceived = "noDataReceived",
+    noFilament = "noFilament",
+    tooLittleMovement = "tooLittleMovement",
+    tooMuchMovement = "tooMuchMovement",
+    sensorError = "sensorError"
+}
+export declare enum FilamentMonitorType {
+    simple = "simple",
+    laser = "laser",
+    pulsed = "pulsed",
+    rotatingMagnet = "rotatingMagnet",
+    unknown = "unknown"
+}
+export default class FilamentMonitorBase extends ModelObject {
+    enabled: boolean;
+    status: FilamentMonitorStatus;
+    type: FilamentMonitorType;
+    constructor(type?: FilamentMonitorType);
+}

package/lib/sensors/FilamentMonitors/FilamentMonitorBase.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilamentMonitorType = exports.FilamentMonitorStatus = void 0;
+const ModelObject_1 = require("../../ModelObject");
+var FilamentMonitorStatus;
+(function (FilamentMonitorStatus) {
+    FilamentMonitorStatus["noMonitor"] = "noMonitor";
+    FilamentMonitorStatus["ok"] = "ok";
+    FilamentMonitorStatus["noDataReceived"] = "noDataReceived";
+    FilamentMonitorStatus["noFilament"] = "noFilament";
+    FilamentMonitorStatus["tooLittleMovement"] = "tooLittleMovement";
+    FilamentMonitorStatus["tooMuchMovement"] = "tooMuchMovement";
+    FilamentMonitorStatus["sensorError"] = "sensorError";
+})(FilamentMonitorStatus = exports.FilamentMonitorStatus || (exports.FilamentMonitorStatus = {}));
+var FilamentMonitorType;
+(function (FilamentMonitorType) {
+    FilamentMonitorType["simple"] = "simple";
+    FilamentMonitorType["laser"] = "laser";
+    FilamentMonitorType["pulsed"] = "pulsed";
+    FilamentMonitorType["rotatingMagnet"] = "rotatingMagnet";
+    FilamentMonitorType["unknown"] = "unknown";
+})(FilamentMonitorType = exports.FilamentMonitorType || (exports.FilamentMonitorType = {}));
+class FilamentMonitorBase extends ModelObject_1.default {
+    constructor(type = FilamentMonitorType.unknown) {
+        super();
+        this.enabled = false;
+        this.status = FilamentMonitorStatus.noDataReceived;
+        this.type = type;
+    }
+}
+exports.default = FilamentMonitorBase;