incyclist-devices 1.5.11 → 1.5.13

package/lib/daum/premium/DaumPremiumProtocol.js

@@ -1,207 +1,207 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const protocol_1 = __importStar(require("../../protocol"));
-const registry_1 = __importDefault(require("../../registry"));
-const bike_1 = require("../premium/bike");
-const DaumPremiumAdapter_1 = __importDefault(require("./DaumPremiumAdapter"));
-const gd_eventlog_1 = require("gd-eventlog");
-const PROTOCOL_NAME = "Daum Premium";
-const DefaultState = {
-    activeScans: [],
-    scanning: false,
-    stopScanning: false
-};
-class DaumPremiumProtocol extends protocol_1.default {
-    constructor() {
-        super();
-        this.state = DefaultState;
-        this.logger = new gd_eventlog_1.EventLogger('DaumPremium');
-        this.devices = [];
-    }
-    add(settings) {
-        if (settings.interface && settings.interface === protocol_1.INTERFACE.TCPIP) {
-            bike_1.Daum8iTcp.setNetImpl(protocol_1.default.getNetImpl());
-            const { host } = settings;
-            const portName = `${host}:51955`;
-            return this.addDevice(bike_1.Daum8iTcp, { host, port: 51955, interface: protocol_1.INTERFACE.TCPIP }, portName);
-        }
-        if (settings.interface && settings.interface === protocol_1.INTERFACE.SERIAL) {
-            bike_1.Daum8iSerial.setSerialPort(protocol_1.default.getSerialPort());
-            const { port } = settings;
-            return this.addDevice(bike_1.Daum8iSerial, { port, interface: protocol_1.INTERFACE.SERIAL }, port);
-        }
-    }
-    getName() {
-        return PROTOCOL_NAME;
-    }
-    getInterfaces() {
-        return [protocol_1.INTERFACE.SERIAL, protocol_1.INTERFACE.TCPIP];
-    }
-    isBike() {
-        return true;
-    }
-    isHrm() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    scan(props) {
-        const opts = props || {};
-        this.logger.logEvent({ message: 'start scan', opts });
-        this.state.scanning = true;
-        if (opts.interface === protocol_1.INTERFACE.TCPIP) {
-            this.scanTcpip(opts);
-        }
-        else if (opts.interface === protocol_1.INTERFACE.SERIAL) {
-            this.scanSerial(opts);
-        }
-    }
-    addDevice(DeviceClass, opts, portName) {
-        let device;
-        if (this.devices.length === 0) {
-            const bike = new DeviceClass(opts);
-            device = new DaumPremiumAdapter_1.default(this, bike);
-            this.devices.push(device);
-        }
-        else {
-            const devices = this.devices;
-            const idx = devices.findIndex(d => d.getBike().getPort() === portName);
-            if (idx === -1) {
-                const bike = new DeviceClass(opts);
-                device = new DaumPremiumAdapter_1.default(this, bike);
-                this.devices.push(device);
-            }
-            else {
-                device = this.devices[idx];
-                if (device.isSelected() || device.isDetected())
-                    device = undefined;
-            }
-        }
-        return device;
-    }
-    scanTcpip(opts) {
-        bike_1.Daum8iTcp.setNetImpl(protocol_1.default.getNetImpl());
-        const { host, port } = opts;
-        let device = this.addDevice(bike_1.Daum8iTcp, opts, `${host}:${port || 51955}`);
-        if (device) {
-            const iv = setInterval(() => { this.scanCommand(device, opts); }, 500);
-            this.state.activeScans.push({ iv, device });
-        }
-    }
-    scanSerial(opts) {
-        bike_1.Daum8iSerial.setSerialPort(protocol_1.default.getSerialPort());
-        let device = this.addDevice(bike_1.Daum8iSerial, opts, opts.port);
-        if (device) {
-            const iv = setInterval(() => { this.scanCommand(device, opts); }, 500);
-            this.state.activeScans.push({ iv, device });
-        }
-    }
-    isScanning() {
-        return this.state.scanning;
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stop scan', activeScans: this.state.activeScans });
-            this.state.stopScanning = true;
-            if (this.state.activeScans.length > 0) {
-                this.state.activeScans.forEach(scan => {
-                    clearInterval(scan.iv);
-                    scan.iv = undefined;
-                    scan.scanning = false;
-                });
-                this.state.activeScans = [];
-            }
-            const devices = this.devices;
-            for (let i = 0; i < devices.length; i++) {
-                const d = devices[i];
-                if (!d.isSelected() && !d.isDetected()) {
-                    try {
-                        yield d.getBike().saveClose(true);
-                    }
-                    catch (err) {
-                        this.logger.logEvent({ message: 'stop scan error', error: err.message });
-                    }
-                }
-            }
-            for (let i = 0; i < devices.length; i++) {
-                const d = devices[i];
-                if (!d.isSelected() && !d.isDetected()) {
-                    try {
-                        yield d.getBike().unblock();
-                    }
-                    catch (err) {
-                    }
-                }
-            }
-            this.state.scanning = false;
-            this.state.stopScanning = false;
-            this.logger.logEvent({ message: 'stop scan completed' });
-            return true;
-        });
-    }
-    scanCommand(device, opts) {
-        const scan = this.state.activeScans.find(actScan => actScan.device.getBike().getPort() === device.getBike().getPort());
-        if (this.state.stopScanning || (scan && scan.scanning) || device.isDetected())
-            return;
-        scan.scanning = true;
-        device.check()
-            .then(() => __awaiter(this, void 0, void 0, function* () {
-            if (this.state.stopScanning)
-                return;
-            const { onDeviceFound, onScanFinished, id } = opts;
-            device.setDetected();
-            if (onDeviceFound)
-                onDeviceFound(device, device.getProtocol());
-            if (onScanFinished) {
-                onScanFinished(id);
-            }
-            try {
-                yield device.getBike().saveClose();
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
-            }
-            clearInterval(scan.iv);
-            scan.iv = undefined;
-            scan.scanning = false;
-        }))
-            .catch(() => {
-            scan.scanning = false;
-        });
-    }
-}
-exports.default = DaumPremiumProtocol;
-const premium = new DaumPremiumProtocol();
-registry_1.default.register(premium);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const protocol_1 = __importStar(require("../../protocol"));
+const registry_1 = __importDefault(require("../../registry"));
+const bike_1 = require("../premium/bike");
+const DaumPremiumAdapter_1 = __importDefault(require("./DaumPremiumAdapter"));
+const gd_eventlog_1 = require("gd-eventlog");
+const PROTOCOL_NAME = "Daum Premium";
+const DefaultState = {
+    activeScans: [],
+    scanning: false,
+    stopScanning: false
+};
+class DaumPremiumProtocol extends protocol_1.default {
+    constructor() {
+        super();
+        this.state = DefaultState;
+        this.logger = new gd_eventlog_1.EventLogger('DaumPremium');
+        this.devices = [];
+    }
+    add(settings) {
+        if (settings.interface && settings.interface === protocol_1.INTERFACE.TCPIP) {
+            bike_1.Daum8iTcp.setNetImpl(protocol_1.default.getNetImpl());
+            const { host } = settings;
+            const portName = `${host}:51955`;
+            return this.addDevice(bike_1.Daum8iTcp, { host, port: 51955, interface: protocol_1.INTERFACE.TCPIP }, portName);
+        }
+        if (settings.interface && settings.interface === protocol_1.INTERFACE.SERIAL) {
+            bike_1.Daum8iSerial.setSerialPort(protocol_1.default.getSerialPort());
+            const { port } = settings;
+            return this.addDevice(bike_1.Daum8iSerial, { port, interface: protocol_1.INTERFACE.SERIAL }, port);
+        }
+    }
+    getName() {
+        return PROTOCOL_NAME;
+    }
+    getInterfaces() {
+        return [protocol_1.INTERFACE.SERIAL, protocol_1.INTERFACE.TCPIP];
+    }
+    isBike() {
+        return true;
+    }
+    isHrm() {
+        return true;
+    }
+    isPower() {
+        return true;
+    }
+    scan(props) {
+        const opts = props || {};
+        this.logger.logEvent({ message: 'start scan', opts });
+        this.state.scanning = true;
+        if (opts.interface === protocol_1.INTERFACE.TCPIP) {
+            this.scanTcpip(opts);
+        }
+        else if (opts.interface === protocol_1.INTERFACE.SERIAL) {
+            this.scanSerial(opts);
+        }
+    }
+    addDevice(DeviceClass, opts, portName) {
+        let device;
+        if (this.devices.length === 0) {
+            const bike = new DeviceClass(opts);
+            device = new DaumPremiumAdapter_1.default(this, bike);
+            this.devices.push(device);
+        }
+        else {
+            const devices = this.devices;
+            const idx = devices.findIndex(d => d.getBike().getPort() === portName);
+            if (idx === -1) {
+                const bike = new DeviceClass(opts);
+                device = new DaumPremiumAdapter_1.default(this, bike);
+                this.devices.push(device);
+            }
+            else {
+                device = this.devices[idx];
+                if (device.isSelected() || device.isDetected())
+                    device = undefined;
+            }
+        }
+        return device;
+    }
+    scanTcpip(opts) {
+        bike_1.Daum8iTcp.setNetImpl(protocol_1.default.getNetImpl());
+        const { host, port } = opts;
+        let device = this.addDevice(bike_1.Daum8iTcp, opts, `${host}:${port || 51955}`);
+        if (device) {
+            const iv = setInterval(() => { this.scanCommand(device, opts); }, 500);
+            this.state.activeScans.push({ iv, device });
+        }
+    }
+    scanSerial(opts) {
+        bike_1.Daum8iSerial.setSerialPort(protocol_1.default.getSerialPort());
+        let device = this.addDevice(bike_1.Daum8iSerial, opts, opts.port);
+        if (device) {
+            const iv = setInterval(() => { this.scanCommand(device, opts); }, 500);
+            this.state.activeScans.push({ iv, device });
+        }
+    }
+    isScanning() {
+        return this.state.scanning;
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stop scan', activeScans: this.state.activeScans });
+            this.state.stopScanning = true;
+            if (this.state.activeScans.length > 0) {
+                this.state.activeScans.forEach(scan => {
+                    clearInterval(scan.iv);
+                    scan.iv = undefined;
+                    scan.scanning = false;
+                });
+                this.state.activeScans = [];
+            }
+            const devices = this.devices;
+            for (let i = 0; i < devices.length; i++) {
+                const d = devices[i];
+                if (!d.isSelected() && !d.isDetected()) {
+                    try {
+                        yield d.getBike().saveClose(true);
+                    }
+                    catch (err) {
+                        this.logger.logEvent({ message: 'stop scan error', error: err.message });
+                    }
+                }
+            }
+            for (let i = 0; i < devices.length; i++) {
+                const d = devices[i];
+                if (!d.isSelected() && !d.isDetected()) {
+                    try {
+                        yield d.getBike().unblock();
+                    }
+                    catch (err) {
+                    }
+                }
+            }
+            this.state.scanning = false;
+            this.state.stopScanning = false;
+            this.logger.logEvent({ message: 'stop scan completed' });
+            return true;
+        });
+    }
+    scanCommand(device, opts) {
+        const scan = this.state.activeScans.find(actScan => actScan.device.getBike().getPort() === device.getBike().getPort());
+        if (this.state.stopScanning || (scan && scan.scanning) || device.isDetected())
+            return;
+        scan.scanning = true;
+        device.check()
+            .then(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.state.stopScanning)
+                return;
+            const { onDeviceFound, onScanFinished, id } = opts;
+            device.setDetected();
+            if (onDeviceFound)
+                onDeviceFound(device, device.getProtocol());
+            if (onScanFinished) {
+                onScanFinished(id);
+            }
+            try {
+                yield device.getBike().saveClose();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
+            }
+            clearInterval(scan.iv);
+            scan.iv = undefined;
+            scan.scanning = false;
+        }))
+            .catch(() => {
+            scan.scanning = false;
+        });
+    }
+}
+exports.default = DaumPremiumProtocol;
+const premium = new DaumPremiumProtocol();
+registry_1.default.register(premium);

package/lib/daum/premium/bike.d.ts

@@ -1,127 +1,127 @@
-/// <reference types="node" />
-import { ReservedCommands } from './utils';
-import { Queue } from '../../utils';
-import { EventLogger } from 'gd-eventlog';
-import { User } from "../../types/user";
-import { Route } from "../../types/route";
-import { OnDeviceStartCallback } from "../../device";
-declare class Daum8i {
-    portName: string;
-    logger: EventLogger;
-    serial: boolean;
-    tcpip: boolean;
-    tcpipConnection: {
-        host: string;
-        port: string;
-    };
-    port: string;
-    settings: any;
-    sendRetryDelay: number;
-    sp: any;
-    props: any;
-    connected: boolean;
-    blocked: boolean;
-    state: any;
-    bikeData: any;
-    processor: any;
-    error: Error;
-    queue: Queue<any>;
-    cmdCurrent: any;
-    cmdStart: number;
-    isLoggingPaused: boolean;
-    constructor(props: any);
-    static getClassName(): string;
-    getType(): string;
-    static setSerialPort(spClass: any): void;
-    static setNetImpl(netClass: any): void;
-    static getSupportedInterfaces(): string[];
-    getPort(): string;
-    isConnected(): boolean;
-    pauseLogging(): void;
-    resumLogging(): void;
-    logEvent(e: any): void;
-    setUser(user: any, callback: any): void;
-    getUserWeight(): any;
-    getBikeWeight(): number;
-    unblock(): void;
-    connect(): void;
-    reconnect(): Promise<void>;
-    saveConnect(): Promise<unknown>;
-    onPortOpen(): void;
-    onPortClose(): void;
-    getLogState(): {
-        sending: any;
-        busy: any;
-        writeBusy: any;
-        opening: any;
-        connecting: any;
-        waitingForStart: any;
-        waitingForEnd: any;
-        waitingForAck: any;
-        retry: any;
-    };
-    onPortError(error: any): void;
-    errorHandler(): void;
-    saveClose(force?: any): Promise<unknown>;
-    forceClose(updateState?: boolean): void;
-    close(): void;
-    sendTimeout(message: any): void;
-    checkForResponse(): boolean;
-    getTimeoutValue(cmd?: any): number;
-    onData(data: any): any;
-    sendDaum8iCommand(command: any, queryType: any, payload: any): Promise<unknown>;
-    sendACK(): void;
-    sendNAK(): void;
-    sendReservedDaum8iCommand(command: ReservedCommands, cmdType: any, data?: Buffer): Promise<any[]>;
-    getProtocolVersion(): Promise<string>;
-    getDashboardVersion(): Promise<unknown>;
-    getDeviceType(): Promise<any>;
-    getActualBikeType(): Promise<any>;
-    setActualBikeType(actualBikeType: any): Promise<any>;
-    getTrainingData(): Promise<{
-        time: number;
-        heartrate: number;
-        speed: number;
-        slope: number;
-        distanceInternal: number;
-        cadence: number;
-        power: number;
-        physEnergy: number;
-        realEnergy: number;
-        torque: number;
-        gear: number;
-        deviceState: number;
-        speedStatus: string;
-    }>;
-    setLoadControl(enabled: any): Promise<boolean>;
-    getLoadControl(): Promise<boolean>;
-    setSlope(slope: any): void;
-    setPower(power: any): Promise<number>;
-    getPower(power: any): Promise<number>;
-    setPerson(person: User): Promise<boolean>;
-    programUploadInit(): Promise<boolean>;
-    programUploadStart(bikeType: string, route?: Route): Promise<Uint8Array>;
-    programUploadSendBlock(epp: Uint8Array, offset: number): Promise<boolean>;
-    programUploadDone(): Promise<boolean>;
-    programUpload(bikeType: string, route: Route, onStatusUpdate?: OnDeviceStartCallback): Promise<boolean>;
-    startProgram(programId?: number): Promise<boolean>;
-    setGear(gear: any): Promise<number>;
-    getGear(): Promise<number>;
-}
-export declare class Daum8iTcp extends Daum8i {
-    static getClassName(): string;
-    getType(): string;
-    static setSerialPort(spClass: any): void;
-    getInterface(): string;
-    static setNetImpl(netClass: any): void;
-    static getSupportedInterfaces(): string[];
-}
-export declare class Daum8iSerial extends Daum8i {
-    static getClassName(): string;
-    getType(): string;
-    getInterface(): string;
-    static setSerialPort(spClass: any): void;
-    static setNetImpl(netClass: any): void;
-    static getSupportedInterfaces(): string[];
-}
-export {};
+/// <reference types="node" />
+import { ReservedCommands } from './utils';
+import { Queue } from '../../utils';
+import { EventLogger } from 'gd-eventlog';
+import { User } from "../../types/user";
+import { Route } from "../../types/route";
+import { OnDeviceStartCallback } from "../../device";
+declare class Daum8i {
+    portName: string;
+    logger: EventLogger;
+    serial: boolean;
+    tcpip: boolean;
+    tcpipConnection: {
+        host: string;
+        port: string;
+    };
+    port: string;
+    settings: any;
+    sendRetryDelay: number;
+    sp: any;
+    props: any;
+    connected: boolean;
+    blocked: boolean;
+    state: any;
+    bikeData: any;
+    processor: any;
+    error: Error;
+    queue: Queue<any>;
+    cmdCurrent: any;
+    cmdStart: number;
+    isLoggingPaused: boolean;
+    constructor(props: any);
+    static getClassName(): string;
+    getType(): string;
+    static setSerialPort(spClass: any): void;
+    static setNetImpl(netClass: any): void;
+    static getSupportedInterfaces(): string[];
+    getPort(): string;
+    isConnected(): boolean;
+    pauseLogging(): void;
+    resumLogging(): void;
+    logEvent(e: any): void;
+    setUser(user: any, callback: any): void;
+    getUserWeight(): any;
+    getBikeWeight(): number;
+    unblock(): void;
+    connect(): void;
+    reconnect(): Promise<void>;
+    saveConnect(): Promise<unknown>;
+    onPortOpen(): void;
+    onPortClose(): void;
+    getLogState(): {
+        sending: any;
+        busy: any;
+        writeBusy: any;
+        opening: any;
+        connecting: any;
+        waitingForStart: any;
+        waitingForEnd: any;
+        waitingForAck: any;
+        retry: any;
+    };
+    onPortError(error: any): void;
+    errorHandler(): void;
+    saveClose(force?: any): Promise<unknown>;
+    forceClose(updateState?: boolean): void;
+    close(): void;
+    sendTimeout(message: any): void;
+    checkForResponse(): boolean;
+    getTimeoutValue(cmd?: any): number;
+    onData(data: any): any;
+    sendDaum8iCommand(command: any, queryType: any, payload: any): Promise<unknown>;
+    sendACK(): void;
+    sendNAK(): void;
+    sendReservedDaum8iCommand(command: ReservedCommands, cmdType: any, data?: Buffer): Promise<any[]>;
+    getProtocolVersion(): Promise<string>;
+    getDashboardVersion(): Promise<unknown>;
+    getDeviceType(): Promise<any>;
+    getActualBikeType(): Promise<any>;
+    setActualBikeType(actualBikeType: any): Promise<any>;
+    getTrainingData(): Promise<{
+        time: number;
+        heartrate: number;
+        speed: number;
+        slope: number;
+        distanceInternal: number;
+        cadence: number;
+        power: number;
+        physEnergy: number;
+        realEnergy: number;
+        torque: number;
+        gear: number;
+        deviceState: number;
+        speedStatus: string;
+    }>;
+    setLoadControl(enabled: any): Promise<boolean>;
+    getLoadControl(): Promise<boolean>;
+    setSlope(slope: any): void;
+    setPower(power: any): Promise<number>;
+    getPower(power: any): Promise<number>;
+    setPerson(person: User): Promise<boolean>;
+    programUploadInit(): Promise<boolean>;
+    programUploadStart(bikeType: string, route?: Route): Promise<Uint8Array>;
+    programUploadSendBlock(epp: Uint8Array, offset: number): Promise<boolean>;
+    programUploadDone(): Promise<boolean>;
+    programUpload(bikeType: string, route: Route, onStatusUpdate?: OnDeviceStartCallback): Promise<boolean>;
+    startProgram(programId?: number): Promise<boolean>;
+    setGear(gear: any): Promise<number>;
+    getGear(): Promise<number>;
+}
+export declare class Daum8iTcp extends Daum8i {
+    static getClassName(): string;
+    getType(): string;
+    static setSerialPort(spClass: any): void;
+    getInterface(): string;
+    static setNetImpl(netClass: any): void;
+    static getSupportedInterfaces(): string[];
+}
+export declare class Daum8iSerial extends Daum8i {
+    static getClassName(): string;
+    getType(): string;
+    getInterface(): string;
+    static setSerialPort(spClass: any): void;
+    static setNetImpl(netClass: any): void;
+    static getSupportedInterfaces(): string[];
+}
+export {};