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

package/dist/src/plugins/PluginManifest.d.ts

@@ -0,0 +1,67 @@
+import ModelObject, { IModelObject } from "../ModelObject";
+import ModelSet from "../ModelSet";
+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 = "writeFirmware",
+    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 declare class PluginManifest extends ModelObject {
+    /**
+     * Constructor of this class
+     * @param itemConstructor Item constructor type that items must derive from
+     */
+    constructor();
+    id: string;
+    name: string;
+    author: string;
+    version: string;
+    license: string;
+    homepage: string | null;
+    tags: Array<string>;
+    dwcVersion: string | null;
+    dwcDependencies: Array<string>;
+    sbcRequired: boolean;
+    sbcDsfVersion: string | null;
+    sbcExecutable: string | null;
+    sbcExecutableArguments: string | null;
+    sbcExtraExecutables: Array<string>;
+    sbcAutoRestart: boolean;
+    sbcOutputRedirected: boolean;
+    sbcPermissions: ModelSet<SbcPermission>;
+    sbcConfigFiles: Array<string>;
+    sbcPackageDependencies: Array<string>;
+    sbcPluginDependencies: Array<string>;
+    sbcPythonDependencies: Array<string>;
+    rrfVersion: string | null;
+    data: Map<string, any>;
+    static checkVersion(actual: string, required: string): boolean;
+    update(jsonElement: any): IModelObject | null;
+}
+export default PluginManifest;

package/dist/src/plugins/PluginManifest.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManifest = exports.SbcPermission = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const ModelSet_1 = __importDefault(require("../ModelSet"));
+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"] = "writeFirmware";
+    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 = SbcPermission = {}));
+class PluginManifest extends ModelObject_1.default {
+    /**
+     * Constructor of this class
+     * @param itemConstructor Item constructor type that items must derive from
+     */
+    constructor() {
+        super();
+        this.id = "";
+        this.name = "";
+        this.author = "";
+        this.version = "1.0.0";
+        this.license = "LGPL-3.0-or-later";
+        this.homepage = null;
+        this.tags = [];
+        this.dwcVersion = null;
+        this.dwcDependencies = [];
+        this.sbcRequired = false;
+        this.sbcDsfVersion = null;
+        this.sbcExecutable = null;
+        this.sbcExecutableArguments = null;
+        this.sbcExtraExecutables = [];
+        this.sbcAutoRestart = false;
+        this.sbcOutputRedirected = true;
+        this.sbcPermissions = new ModelSet_1.default();
+        this.sbcConfigFiles = [];
+        this.sbcPackageDependencies = [];
+        this.sbcPluginDependencies = [];
+        this.sbcPythonDependencies = [];
+        this.rrfVersion = null;
+        this.data = new Map();
+        let id = "";
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            get() { return id; },
+            set(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");
+                    }
+                }
+                id = value;
+            }
+        });
+        let name = "";
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            get() { return name; },
+            set(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");
+                    }
+                }
+                name = value;
+            }
+        });
+    }
+    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;
+    }
+    update(jsonElement) {
+        if (typeof jsonElement.data === "object") {
+            for (const key in jsonElement.data) {
+                this.data.set(key, jsonElement.data[key]);
+            }
+            delete jsonElement.data;
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.PluginManifest = PluginManifest;
+exports.default = PluginManifest;

package/dist/src/plugins/index.d.ts

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

package/dist/src/plugins/index.js

@@ -0,0 +1,33 @@
+"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.Plugin = void 0;
+const PluginManifest_1 = __importDefault(require("./PluginManifest"));
+class Plugin extends PluginManifest_1.default {
+    constructor() {
+        super(...arguments);
+        this.dsfFiles = [];
+        this.dwcFiles = [];
+        this.sdFiles = [];
+        this.pid = -1;
+    }
+}
+exports.Plugin = Plugin;
+exports.default = Plugin;
+__exportStar(require("./PluginManifest"), exports);

package/dist/src/sbc/CPU.d.ts

@@ -0,0 +1,8 @@
+import ModelObject from "../ModelObject";
+export declare class CPU extends ModelObject {
+    avgLoad: number | null;
+    hardware: string | null;
+    numCores: number;
+    temperature: number | null;
+}
+export default CPU;

package/dist/src/sbc/CPU.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CPU = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+class CPU extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.avgLoad = null;
+        this.hardware = null;
+        this.numCores = 1;
+        this.temperature = null;
+    }
+}
+exports.CPU = CPU;
+exports.default = CPU;

package/dist/src/sbc/Memory.d.ts

@@ -0,0 +1,6 @@
+import ModelObject from "../ModelObject";
+export declare class Memory extends ModelObject {
+    available: number | null;
+    total: number | null;
+}
+export default Memory;

package/dist/src/sbc/Memory.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+class Memory extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.available = null;
+        this.total = null;
+    }
+}
+exports.Memory = Memory;
+exports.default = Memory;

package/dist/src/sbc/dsf/HttpEndpoint.d.ts

@@ -0,0 +1,19 @@
+import ModelObject from "../../ModelObject";
+export declare enum HttpEndpointType {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    TRACE = "TRACE",
+    DELETE = "DELETE",
+    OPTIONS = "OPTIONS",
+    WebSocket = "WebSocket"
+}
+export declare class HttpEndpoint extends ModelObject {
+    endpointType: HttpEndpointType;
+    namespace: string;
+    path: string;
+    isUploadRequest: boolean;
+    unixSocket: string;
+}
+export default HttpEndpoint;

package/dist/src/sbc/dsf/HttpEndpoint.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpEndpoint = exports.HttpEndpointType = void 0;
+const ModelObject_1 = __importDefault(require("../../ModelObject"));
+var HttpEndpointType;
+(function (HttpEndpointType) {
+    HttpEndpointType["GET"] = "GET";
+    HttpEndpointType["POST"] = "POST";
+    HttpEndpointType["PUT"] = "PUT";
+    HttpEndpointType["PATCH"] = "PATCH";
+    HttpEndpointType["TRACE"] = "TRACE";
+    HttpEndpointType["DELETE"] = "DELETE";
+    HttpEndpointType["OPTIONS"] = "OPTIONS";
+    HttpEndpointType["WebSocket"] = "WebSocket";
+})(HttpEndpointType || (exports.HttpEndpointType = HttpEndpointType = {}));
+class HttpEndpoint extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.endpointType = HttpEndpointType.GET;
+        this.namespace = "";
+        this.path = "";
+        this.isUploadRequest = false;
+        this.unixSocket = "";
+    }
+}
+exports.HttpEndpoint = HttpEndpoint;
+exports.default = HttpEndpoint;

package/dist/src/sbc/dsf/UserSession.d.ts

@@ -0,0 +1,18 @@
+import ModelObject from "../../ModelObject";
+export declare enum AccessLevel {
+    readOnly = "readOnly",
+    readWrite = "readWrite"
+}
+export declare enum SessionType {
+    local = "local",
+    http = "http",
+    telnet = "telnet"
+}
+export declare class UserSession extends ModelObject {
+    accessLevel: AccessLevel;
+    id: number;
+    origin: string | null;
+    originId: number;
+    sessionType: SessionType;
+}
+export default UserSession;

package/dist/src/sbc/dsf/UserSession.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSession = exports.SessionType = exports.AccessLevel = void 0;
+const ModelObject_1 = __importDefault(require("../../ModelObject"));
+var AccessLevel;
+(function (AccessLevel) {
+    AccessLevel["readOnly"] = "readOnly";
+    AccessLevel["readWrite"] = "readWrite";
+})(AccessLevel || (exports.AccessLevel = AccessLevel = {}));
+var SessionType;
+(function (SessionType) {
+    SessionType["local"] = "local";
+    SessionType["http"] = "http";
+    SessionType["telnet"] = "telnet";
+})(SessionType || (exports.SessionType = SessionType = {}));
+class UserSession extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.accessLevel = AccessLevel.readOnly;
+        this.id = 0;
+        this.origin = null;
+        this.originId = -1;
+        this.sessionType = SessionType.local;
+    }
+}
+exports.UserSession = UserSession;
+exports.default = UserSession;

package/dist/src/sbc/dsf/index.d.ts

@@ -0,0 +1,15 @@
+import ModelCollection from "../../ModelCollection";
+import ModelObject from "../../ModelObject";
+import HttpEndpoint from "./HttpEndpoint";
+import UserSession from "./UserSession";
+export declare class DSF extends ModelObject {
+    buildDateTime: string;
+    readonly httpEndpoints: ModelCollection<HttpEndpoint>;
+    is64Bit: boolean;
+    pluginSupport: boolean;
+    rootPluginSupport: boolean;
+    readonly userSessions: ModelCollection<UserSession>;
+    version: string;
+}
+export default DSF;
+export * from "./HttpEndpoint";

package/dist/src/sbc/dsf/index.js

@@ -0,0 +1,39 @@
+"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.DSF = void 0;
+const ModelCollection_1 = __importDefault(require("../../ModelCollection"));
+const ModelObject_1 = __importDefault(require("../../ModelObject"));
+const HttpEndpoint_1 = __importDefault(require("./HttpEndpoint"));
+const UserSession_1 = __importDefault(require("./UserSession"));
+class DSF extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.buildDateTime = "";
+        this.httpEndpoints = new ModelCollection_1.default(HttpEndpoint_1.default);
+        this.is64Bit = false;
+        this.pluginSupport = false;
+        this.rootPluginSupport = false;
+        this.userSessions = new ModelCollection_1.default(UserSession_1.default);
+        this.version = "";
+    }
+}
+exports.DSF = DSF;
+exports.default = DSF;
+__exportStar(require("./HttpEndpoint"), exports);

package/dist/src/sbc/index.d.ts

@@ -0,0 +1,19 @@
+import ModelObject from "../ModelObject";
+import DSF from "./dsf";
+import CPU from "./CPU";
+import Memory from "./Memory";
+export declare class SBC extends ModelObject {
+    appArmor: boolean;
+    readonly cpu: CPU;
+    readonly dsf: DSF;
+    distribution: string | null;
+    distributionBuildTime: string | null;
+    readonly memory: Memory;
+    model: string | null;
+    serial: string | null;
+    uptime: number | null;
+}
+export default SBC;
+export * from "./dsf";
+export * from "./CPU";
+export * from "./Memory";

package/dist/src/sbc/index.js

@@ -0,0 +1,43 @@
+"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.SBC = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const dsf_1 = __importDefault(require("./dsf"));
+const CPU_1 = __importDefault(require("./CPU"));
+const Memory_1 = __importDefault(require("./Memory"));
+class SBC extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.appArmor = false;
+        this.cpu = new CPU_1.default();
+        this.dsf = new dsf_1.default();
+        this.distribution = null;
+        this.distributionBuildTime = null;
+        this.memory = new Memory_1.default();
+        this.model = null;
+        this.serial = null;
+        this.uptime = null;
+    }
+}
+exports.SBC = SBC;
+exports.default = SBC;
+__exportStar(require("./dsf"), exports);
+__exportStar(require("./CPU"), exports);
+__exportStar(require("./Memory"), exports);

package/dist/src/sensors/AnalogSensor.d.ts

@@ -0,0 +1,59 @@
+import ModelObject from "../ModelObject";
+export declare enum AnalogSensorType {
+    thermistor = "thermistor",
+    pt1000 = "pt1000",
+    max31865 = "rtdmax31865",
+    max31855 = "thermocouplemax31855",
+    max31856 = "thermocouplemax31856",
+    linearAnalog = "linearanalog",
+    dht21 = "dht21",
+    dht22 = "dht22",
+    dhtHumidity = "dhthumidity",
+    bme280 = "bme280",
+    bme280pressure = "bmepressure",
+    bme280humidity = "bmehumidity",
+    currentLoop = "currentloooppyro",
+    ads131chan0 = "ads131.chan0",
+    ads131chan1 = "ads131.chan1",
+    mcuTemp = "mcutemp",
+    drivers = "drivers",
+    driversDuex = "driversduex",
+    unknown = "unknown"
+}
+export declare enum TemperatureError {
+    ok = "ok",
+    shortCircuit = "shortCircuit",
+    shortToVcc = "shortToVcc",
+    shortToGround = "shortToGround",
+    openCircuit = "openCircuit",
+    timeout = "timeout",
+    ioError = "ioError",
+    hardwareError = "hardwareError",
+    notReady = "notReady",
+    invalidOutputNumber = "invalidOutputNumber",
+    busBusy = "busBusy",
+    badResponse = "badResponse",
+    unknownPort = "unknownPort",
+    notInitialised = "notInitialised",
+    unknownSensor = "unknownSensor",
+    overOrUnderVoltage = "overOrUnderVoltage",
+    badVref = "badVref",
+    badVssa = "badVssa",
+    unknownError = "unknownError"
+}
+export declare class AnalogSensor extends ModelObject {
+    beta: number | null;
+    c: number | null;
+    highReading: number | null;
+    lastReading: number | null;
+    lowReading: number | null;
+    name: string | null;
+    offsetAdj: number;
+    port: string | null;
+    r25: number | null;
+    rRef: number | null;
+    slopeAdj: number;
+    state: TemperatureError;
+    type: AnalogSensorType;
+}
+export default AnalogSensor;

package/dist/src/sensors/AnalogSensor.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalogSensor = exports.TemperatureError = exports.AnalogSensorType = void 0;
+const ModelObject_1 = __importDefault(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["dht21"] = "dht21";
+    AnalogSensorType["dht22"] = "dht22";
+    AnalogSensorType["dhtHumidity"] = "dhthumidity";
+    AnalogSensorType["bme280"] = "bme280";
+    AnalogSensorType["bme280pressure"] = "bmepressure";
+    AnalogSensorType["bme280humidity"] = "bmehumidity";
+    AnalogSensorType["currentLoop"] = "currentloooppyro";
+    AnalogSensorType["ads131chan0"] = "ads131.chan0";
+    AnalogSensorType["ads131chan1"] = "ads131.chan1";
+    AnalogSensorType["mcuTemp"] = "mcutemp";
+    AnalogSensorType["drivers"] = "drivers";
+    AnalogSensorType["driversDuex"] = "driversduex";
+    AnalogSensorType["unknown"] = "unknown";
+})(AnalogSensorType || (exports.AnalogSensorType = AnalogSensorType = {}));
+var TemperatureError;
+(function (TemperatureError) {
+    TemperatureError["ok"] = "ok";
+    TemperatureError["shortCircuit"] = "shortCircuit";
+    TemperatureError["shortToVcc"] = "shortToVcc";
+    TemperatureError["shortToGround"] = "shortToGround";
+    TemperatureError["openCircuit"] = "openCircuit";
+    TemperatureError["timeout"] = "timeout";
+    TemperatureError["ioError"] = "ioError";
+    TemperatureError["hardwareError"] = "hardwareError";
+    TemperatureError["notReady"] = "notReady";
+    TemperatureError["invalidOutputNumber"] = "invalidOutputNumber";
+    TemperatureError["busBusy"] = "busBusy";
+    TemperatureError["badResponse"] = "badResponse";
+    TemperatureError["unknownPort"] = "unknownPort";
+    TemperatureError["notInitialised"] = "notInitialised";
+    TemperatureError["unknownSensor"] = "unknownSensor";
+    TemperatureError["overOrUnderVoltage"] = "overOrUnderVoltage";
+    TemperatureError["badVref"] = "badVref";
+    TemperatureError["badVssa"] = "badVssa";
+    TemperatureError["unknownError"] = "unknownError";
+})(TemperatureError || (exports.TemperatureError = TemperatureError = {}));
+class AnalogSensor extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.beta = null;
+        this.c = null;
+        this.highReading = null;
+        this.lastReading = null;
+        this.lowReading = null;
+        this.name = null;
+        this.offsetAdj = 0;
+        this.port = null;
+        this.r25 = null;
+        this.rRef = null;
+        this.slopeAdj = 0;
+        this.state = TemperatureError.ok;
+        this.type = AnalogSensorType.unknown;
+    }
+}
+exports.AnalogSensor = AnalogSensor;
+exports.default = AnalogSensor;

package/dist/src/sensors/Endstop.d.ts

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