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

package/dist/src/ModelObject.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelObject = void 0;
+exports.isModelObject = isModelObject;
+exports.initObject = initObject;
+const index_1 = require("./index");
+/**
+ * Check whether a given value provides model update functionality
+ * @param value Value to check
+ */
+function isModelObject(value) {
+    return (value instanceof Object) && value.update !== undefined;
+}
+/**
+ * Base class for object model classes
+ */
+class ModelObject {
+    /**
+     * Update this instance from the given data
+     * @param jsonElement JSON data to upgrade this instance from
+     * @returns Updated instance (may not equal the original instance)
+     */
+    update(jsonElement) {
+        if (jsonElement === null) {
+            return null;
+        }
+        for (const [key, value] of Object.entries(jsonElement)) {
+            if (key in this) {
+                const ownKey = key;
+                const prop = this[ownKey];
+                if (isModelObject(prop)) {
+                    // Update model objects
+                    const updatedObject = prop.update(value);
+                    if (prop !== updatedObject) {
+                        const propDescriptor = Object.getOwnPropertyDescriptor(this, key);
+                        if (propDescriptor !== undefined) {
+                            if (propDescriptor.writable || propDescriptor.set !== undefined) {
+                                this[ownKey] = updatedObject;
+                            }
+                            else if (process.env.NODE_ENV !== "production") {
+                                console.warn(`Model object ${key} changed but it could not be set due to missing setter`);
+                            }
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Model object ${key} changed but it lacks the property descriptor`);
+                        }
+                    }
+                }
+                else if (prop instanceof Array) {
+                    if (value instanceof Array) {
+                        // Remove deleted items
+                        prop.splice(value.length);
+                        // Update existing items
+                        for (let i = 0; i < Math.min(prop.length, value.length); i++) {
+                            const propItem = prop[i];
+                            if (propItem === null) {
+                                (0, index_1.setArrayItem)(prop, i, value[i]);
+                            }
+                            else {
+                                const newItem = value[i];
+                                if (propItem !== newItem) {
+                                    (0, index_1.setArrayItem)(prop, i, newItem);
+                                }
+                            }
+                        }
+                        // Add new items
+                        for (let i = prop.length; i < value.length; i++) {
+                            prop.push(value[i]);
+                        }
+                    }
+                    else if (value === null) {
+                        // Arrays may be assignable to null
+                        this[ownKey] = value;
+                    }
+                    else if (process.env.NODE_ENV !== "production") {
+                        console.warn(`Model array ${key} could not be changed because the target type ${typeof value} is invalid`);
+                    }
+                }
+                else if (prop instanceof Set) {
+                    if (value instanceof Array || value instanceof Set) {
+                        // Remove deleted items
+                        for (let item of new Set(prop)) {
+                            if (!prop.has(item)) {
+                                prop.delete(item);
+                            }
+                        }
+                        // Add new items
+                        for (let item of value) {
+                            if (!prop.has(item)) {
+                                prop.add(item);
+                            }
+                        }
+                    }
+                    else if (value === null) {
+                        // Sets may be assignable to null
+                        this[ownKey] = value;
+                    }
+                    else if (process.env.NODE_ENV !== "production") {
+                        console.warn(`Model set ${key} could not be changed because the target type ${typeof value} is invalid`);
+                    }
+                }
+                else if (prop === null || value === null) {
+                    // Unfortunately we cannot do type checks during runtime without excessive extra work and possibly
+                    // third-party libraries, so skip them for null values until there is a better solution.
+                    // FWIW, we would just need "typeof prop" but TS does not seem to be capable of providing this.
+                    this[ownKey] = value;
+                }
+                else {
+                    const propType = typeof prop;
+                    if (propType === "boolean") {
+                        if (typeof value === "boolean") {
+                            this[ownKey] = value;
+                        }
+                        else if (typeof value === "number") {
+                            // RRF used to report booleans as integers so convert them if necessary
+                            this[ownKey] = Boolean(value);
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible bool target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "number") {
+                        if (typeof value === "number" || typeof value === "bigint") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible number target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "bigint") {
+                        if (typeof value === "number" || typeof value === "bigint") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible bigint target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "string") {
+                        if (typeof value === "string") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible string target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "function") {
+                        if (typeof value === "function") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible function target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "object") {
+                        if (typeof value === "object") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible object target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (process.env.NODE_ENV !== "production") {
+                        console.warn(`Incompatible type ${propType} for property ${key} (${typeof value})`);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    /**
+     * Wrap a nullable model object property so that type checks can be performed
+     * @param key Property key of the derived class
+     * @param constructor Constructor for creating new elements
+     */
+    static wrapModelCollectionProperty(self, key, itemConstructor) {
+        let propertyValue = self[key];
+        Object.defineProperty(self, key, {
+            get() { return propertyValue; },
+            set(newValue) {
+                if (newValue === null) {
+                    propertyValue = null;
+                }
+                else if (propertyValue !== null) {
+                    const newModel = propertyValue.update(newValue);
+                    if (propertyValue !== newModel) {
+                        propertyValue = newModel;
+                    }
+                }
+                else {
+                    const newModel = new index_1.ModelCollection(itemConstructor);
+                    propertyValue = newModel.update(newValue);
+                }
+            },
+            configurable: true,
+            enumerable: true
+        });
+    }
+    /**
+     * Wrap a nullable model object property so that type checks can be performed
+     * @param key Property key of the derived class
+     * @param constructor Constructor for creating new elements
+     */
+    static wrapModelProperty(self, key, constructor) {
+        let propertyValue = self[key];
+        Object.defineProperty(self, key, {
+            get() { return propertyValue; },
+            set(newValue) {
+                if (newValue === null) {
+                    propertyValue = null;
+                }
+                else if (propertyValue !== null) {
+                    const newModel = propertyValue.update(newValue);
+                    if (propertyValue !== newModel) {
+                        propertyValue = newModel;
+                    }
+                }
+                else {
+                    const newModel = new constructor();
+                    propertyValue = newModel.update(newValue);
+                }
+            },
+            configurable: true,
+            enumerable: true
+        });
+    }
+}
+exports.ModelObject = ModelObject;
+exports.default = ModelObject;
+/**
+ * Initialize a model object from the given data
+ * @param itemType Model type to create
+ * @param data Data to assign
+ * @returns Initialized model instance
+ */
+function initObject(itemType, data) {
+    return new itemType().update(data);
+}

package/dist/src/ModelSet.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrapper around a standard set to make sure it serializes to an array
+ */
+export declare class ModelSet<T> extends Set<T> {
+    /**
+     * Convert this object to JSON
+     * @returns JSON object
+     */
+    toJSON(): T[];
+}
+export default ModelSet;

package/dist/src/ModelSet.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelSet = void 0;
+/**
+ * Wrapper around a standard set to make sure it serializes to an array
+ */
+class ModelSet extends Set {
+    /**
+     * Convert this object to JSON
+     * @returns JSON object
+     */
+    toJSON() { return Array.from(this); }
+}
+exports.ModelSet = ModelSet;
+exports.default = ModelSet;

package/dist/src/ObjectModel.d.ts

@@ -0,0 +1,47 @@
+import ModelCollection from "./ModelCollection";
+import ModelDictionary from "./ModelDictionary";
+import ModelObject from "./ModelObject";
+import Board from "./boards";
+import Directories from "./directories";
+import Fan from "./fans";
+import Heat from "./heat";
+import InputChannel from "./inputs/InputChannel";
+import Job from "./job";
+import Limits from "./limits";
+import Message from "./messages";
+import Move from "./move";
+import Network from "./network";
+import Plugin from "./plugins";
+import SBC from "./sbc";
+import Sensors from "./sensors";
+import Spindle from "./spindles";
+import State from "./state";
+import Tool from "./tools";
+import Volume from "./volumes";
+import LedStrip from "./ledStrips";
+/**
+ * Refer to the DSF/RRF documentation for descriptions of the object model fields
+ */
+export declare class ObjectModel extends ModelObject {
+    constructor();
+    readonly boards: ModelCollection<Board>;
+    readonly directories: Directories;
+    readonly fans: ModelCollection<Fan | null>;
+    readonly global: ModelDictionary<any>;
+    readonly heat: Heat;
+    readonly inputs: ModelCollection<InputChannel | null>;
+    readonly job: Job;
+    readonly ledStrips: ModelCollection<LedStrip>;
+    readonly limits: Limits;
+    readonly messages: ModelCollection<Message>;
+    readonly move: Move;
+    readonly network: Network;
+    readonly plugins: ModelDictionary<Plugin>;
+    sbc: SBC | null;
+    readonly sensors: Sensors;
+    readonly spindles: ModelCollection<Spindle | null>;
+    readonly state: State;
+    readonly tools: ModelCollection<Tool | null>;
+    readonly volumes: ModelCollection<Volume>;
+}
+export default ObjectModel;

package/dist/src/ObjectModel.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectModel = void 0;
+const ModelCollection_1 = __importDefault(require("./ModelCollection"));
+const ModelDictionary_1 = __importDefault(require("./ModelDictionary"));
+const ModelObject_1 = __importDefault(require("./ModelObject"));
+const boards_1 = __importDefault(require("./boards"));
+const directories_1 = __importDefault(require("./directories"));
+const fans_1 = __importDefault(require("./fans"));
+const heat_1 = __importDefault(require("./heat"));
+const InputChannel_1 = __importDefault(require("./inputs/InputChannel"));
+const job_1 = __importDefault(require("./job"));
+const limits_1 = __importDefault(require("./limits"));
+const messages_1 = __importDefault(require("./messages"));
+const move_1 = __importDefault(require("./move"));
+const network_1 = __importDefault(require("./network"));
+const plugins_1 = __importDefault(require("./plugins"));
+const sbc_1 = __importDefault(require("./sbc"));
+const sensors_1 = __importDefault(require("./sensors"));
+const spindles_1 = __importDefault(require("./spindles"));
+const state_1 = __importDefault(require("./state"));
+const tools_1 = __importDefault(require("./tools"));
+const volumes_1 = __importDefault(require("./volumes"));
+const ledStrips_1 = __importDefault(require("./ledStrips"));
+/**
+ * Refer to the DSF/RRF documentation for descriptions of the object model fields
+ */
+class ObjectModel extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.boards = new ModelCollection_1.default(boards_1.default);
+        this.directories = new directories_1.default();
+        this.fans = new ModelCollection_1.default(fans_1.default);
+        this.global = new ModelDictionary_1.default(false);
+        this.heat = new heat_1.default();
+        this.inputs = new ModelCollection_1.default(InputChannel_1.default);
+        this.job = new job_1.default();
+        this.ledStrips = new ModelCollection_1.default(ledStrips_1.default);
+        this.limits = new limits_1.default();
+        this.messages = new ModelCollection_1.default(messages_1.default); // must be manually cleared after updates
+        this.move = new move_1.default();
+        this.network = new network_1.default();
+        this.plugins = new ModelDictionary_1.default(true, plugins_1.default);
+        this.sbc = null;
+        this.sensors = new sensors_1.default();
+        this.spindles = new ModelCollection_1.default(spindles_1.default);
+        this.state = new state_1.default();
+        this.tools = new ModelCollection_1.default(tools_1.default);
+        this.volumes = new ModelCollection_1.default(volumes_1.default);
+        ModelObject_1.default.wrapModelProperty(this, "sbc", sbc_1.default);
+    }
+}
+exports.ObjectModel = ObjectModel;
+exports.default = ObjectModel;

package/dist/src/boards/Driver.d.ts

@@ -0,0 +1,18 @@
+import { ModelObject } from "..";
+export declare class BoardClosedLoopCurrentFraction extends ModelObject {
+    avg: number;
+    max: number;
+}
+export declare class BoardClosedLoopPositionError extends ModelObject {
+    max: number;
+    rms: number;
+}
+export declare class DriverClosedLoop extends ModelObject {
+    readonly currentFraction: BoardClosedLoopCurrentFraction;
+    readonly positionError: BoardClosedLoopPositionError;
+}
+export default class Driver extends ModelObject {
+    constructor();
+    closedLoop: DriverClosedLoop | null;
+    status: number;
+}

package/dist/src/boards/Driver.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriverClosedLoop = exports.BoardClosedLoopPositionError = exports.BoardClosedLoopCurrentFraction = void 0;
+const __1 = require("..");
+class BoardClosedLoopCurrentFraction extends __1.ModelObject {
+    constructor() {
+        super(...arguments);
+        this.avg = 0;
+        this.max = 0;
+    }
+}
+exports.BoardClosedLoopCurrentFraction = BoardClosedLoopCurrentFraction;
+class BoardClosedLoopPositionError extends __1.ModelObject {
+    constructor() {
+        super(...arguments);
+        this.max = 0;
+        this.rms = 0;
+    }
+}
+exports.BoardClosedLoopPositionError = BoardClosedLoopPositionError;
+class DriverClosedLoop extends __1.ModelObject {
+    constructor() {
+        super(...arguments);
+        this.currentFraction = new BoardClosedLoopCurrentFraction();
+        this.positionError = new BoardClosedLoopPositionError();
+    }
+}
+exports.DriverClosedLoop = DriverClosedLoop;
+class Driver extends __1.ModelObject {
+    constructor() {
+        super();
+        this.closedLoop = null;
+        this.status = 0;
+        __1.ModelObject.wrapModelProperty(this, "closedLoop", DriverClosedLoop);
+    }
+}
+exports.default = Driver;

package/dist/src/boards/directDisplay/DirectDisplayScreen.d.ts

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

package/dist/src/boards/directDisplay/DirectDisplayScreen.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectDisplayScreen = void 0;
+const _1 = require(".");
+const DirectDisplayScreenBase_1 = __importDefault(require("./DirectDisplayScreenBase"));
+class DirectDisplayScreen extends DirectDisplayScreenBase_1.default {
+    update(jsonElement) {
+        if (jsonElement === null) {
+            return null;
+        }
+        if (typeof jsonElement.controller === "string" && jsonElement.controller !== this.controller) {
+            return (0, _1.getDirectDisplayScreen)(jsonElement.controller).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.DirectDisplayScreen = DirectDisplayScreen;
+exports.default = DirectDisplayScreen;

package/dist/src/boards/directDisplay/DirectDisplayScreenBase.d.ts

@@ -0,0 +1,11 @@
+import ModelObject from "../../ModelObject";
+import { DirectDisplayController } from ".";
+export declare class DirectDisplayScreenBase extends ModelObject {
+    constructor(type: DirectDisplayController);
+    colourBits: number;
+    controller: DirectDisplayController;
+    height: number;
+    spiFreq: number;
+    width: number;
+}
+export default DirectDisplayScreenBase;

package/dist/src/boards/directDisplay/DirectDisplayScreenBase.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectDisplayScreenBase = void 0;
+const ModelObject_1 = __importDefault(require("../../ModelObject"));
+class DirectDisplayScreenBase extends ModelObject_1.default {
+    constructor(type) {
+        super();
+        this.colourBits = 1;
+        this.height = 64;
+        this.spiFreq = 2000000;
+        this.width = 128;
+        this.controller = type;
+    }
+}
+exports.DirectDisplayScreenBase = DirectDisplayScreenBase;
+exports.default = DirectDisplayScreenBase;

package/dist/src/boards/directDisplay/DirectDisplayScreenST7567.d.ts

@@ -0,0 +1,9 @@
+import { IModelObject } from "../../ModelObject";
+import DirectDisplayScreenBase from "./DirectDisplayScreen";
+export declare class DirectDisplayScreenST7567 extends DirectDisplayScreenBase {
+    constructor();
+    contrast: number;
+    resistorRatio: number;
+    update(jsonElement: any): IModelObject | null;
+}
+export default DirectDisplayScreenST7567;

package/dist/src/boards/directDisplay/DirectDisplayScreenST7567.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectDisplayScreenST7567 = void 0;
+const DirectDisplayScreen_1 = __importDefault(require("./DirectDisplayScreen"));
+const _1 = require(".");
+class DirectDisplayScreenST7567 extends DirectDisplayScreen_1.default {
+    constructor() {
+        super(_1.DirectDisplayController.ST7567);
+        this.contrast = 30;
+        this.resistorRatio = 6;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            return null;
+        }
+        if (typeof jsonElement.controller === "string" && jsonElement.controller !== this.controller) {
+            return (0, _1.getDirectDisplayScreen)(jsonElement.type).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.DirectDisplayScreenST7567 = DirectDisplayScreenST7567;
+exports.default = DirectDisplayScreenST7567;

package/dist/src/boards/directDisplay/index.d.ts

@@ -0,0 +1,20 @@
+import ModelObject from "../../ModelObject";
+import DirectDisplayScreenBase from "./DirectDisplayScreenBase";
+import DirectDisplayScreen from "./DirectDisplayScreen";
+export declare enum DirectDisplayController {
+    ST7920 = "ST7920",
+    ST7567 = "ST7567",
+    ILI9488 = "ILI9488"
+}
+export declare class DirectDisplayEncoder extends ModelObject {
+    pulsesPerClick: number;
+}
+export declare class DirectDisplay extends ModelObject {
+    constructor();
+    encoder: DirectDisplayEncoder | null;
+    screen: DirectDisplayScreenBase;
+}
+export default DirectDisplay;
+export declare function getDirectDisplayScreen(controller: DirectDisplayController): DirectDisplayScreen;
+export * from "./DirectDisplayScreen";
+export * from "./DirectDisplayScreenST7567";

package/dist/src/boards/directDisplay/index.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 __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.DirectDisplay = exports.DirectDisplayEncoder = exports.DirectDisplayController = void 0;
+exports.getDirectDisplayScreen = getDirectDisplayScreen;
+const ModelObject_1 = __importDefault(require("../../ModelObject"));
+const DirectDisplayScreen_1 = __importDefault(require("./DirectDisplayScreen"));
+const DirectDisplayScreenST7567_1 = require("./DirectDisplayScreenST7567");
+var DirectDisplayController;
+(function (DirectDisplayController) {
+    DirectDisplayController["ST7920"] = "ST7920";
+    DirectDisplayController["ST7567"] = "ST7567";
+    DirectDisplayController["ILI9488"] = "ILI9488";
+})(DirectDisplayController || (exports.DirectDisplayController = DirectDisplayController = {}));
+class DirectDisplayEncoder extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.pulsesPerClick = 1;
+    }
+}
+exports.DirectDisplayEncoder = DirectDisplayEncoder;
+class DirectDisplay extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.encoder = new DirectDisplayEncoder();
+        this.screen = new DirectDisplayScreen_1.default(DirectDisplayController.ST7920);
+        ModelObject_1.default.wrapModelProperty(this, "encoder", DirectDisplayEncoder);
+    }
+}
+exports.DirectDisplay = DirectDisplay;
+exports.default = DirectDisplay;
+function getDirectDisplayScreen(controller) {
+    switch (controller) {
+        case DirectDisplayController.ST7920:
+        case DirectDisplayController.ILI9488:
+        default:
+            return new DirectDisplayScreen_1.default(controller);
+        case DirectDisplayController.ST7567:
+            return new DirectDisplayScreenST7567_1.DirectDisplayScreenST7567();
+    }
+}
+__exportStar(require("./DirectDisplayScreen"), exports);
+__exportStar(require("./DirectDisplayScreenST7567"), exports);

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

@@ -0,0 +1,59 @@
+import ModelCollection from "../ModelCollection";
+import ModelObject from "../ModelObject";
+import DirectDisplay from "./directDisplay";
+import Driver from "./Driver";
+export declare class Accelerometer extends ModelObject {
+    orientation: number;
+    points: number;
+    runs: number;
+}
+export declare class BoardClosedLoop extends ModelObject {
+    points: number;
+    runs: number;
+}
+export declare enum BoardState {
+    unknown = "unknown",
+    flashing = "flashing",
+    flashFailed = "flashFailed",
+    resetting = "resetting",
+    running = "running",
+    timedOut = "timedOut"
+}
+export declare class InductiveSensor extends ModelObject {
+}
+export declare class MinMaxCurrent extends ModelObject {
+    current: number;
+    min: number;
+    max: number;
+}
+export declare class Board extends ModelObject {
+    constructor();
+    accelerometer: Accelerometer | null;
+    bootloaderFileName: string | null;
+    canAddress: number | null;
+    closedLoop: BoardClosedLoop | null;
+    directDisplay: DirectDisplay | null;
+    drivers: ModelCollection<Driver> | null;
+    firmwareDate: string;
+    firmwareFileName: string;
+    firmwareName: string;
+    firmwareVersion: string;
+    freeRam: number | null;
+    iapFileNameSBC: string | null;
+    iapFileNameSD: string | null;
+    inductiveSensor: InductiveSensor | null;
+    maxHeaters: number;
+    maxMotors: number;
+    mcuTemp: MinMaxCurrent | null;
+    name: string;
+    shortName: string;
+    state: BoardState;
+    supportsDirectDisplay: boolean;
+    uniqueId: string | null;
+    v12: MinMaxCurrent | null;
+    vIn: MinMaxCurrent | null;
+    wifiFirmwareFileName: string | null;
+}
+export default Board;
+export * from "./directDisplay";
+export * from "./Driver";