incyclist-devices 1.4.8 → 1.4.11

package/lib/daum/premium/DaumPremiumProtocol.js

@@ -1,23 +1,4 @@
 "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) {
@@ -27,6 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/lib/daum/premium/bike.js

@@ -12,7 +12,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Daum8iSerial = exports.Daum8iTcp = void 0;
 const constants_1 = require("../constants");
 const tcpserial_1 = __importDefault(require("./tcpserial"));
 const utils_1 = require("./utils");
@@ -26,6 +25,8 @@ const OPEN_TIMEOUT = 1000;
 const DAUM_PREMIUM_DEFAULT_PORT = 51955;
 const DAUM_PREMIUM_DEFAULT_HOST = '127.0.0.1';
 const MAX_DATA_BLOCK_SIZE = 512;
+const DS_BITS_OFF = 0;
+const DS_BITS_ENDLESS_RACE = 2;
 var __SerialPort = undefined;
 var net = undefined;
 const DEBUG_LOGGER = {
@@ -406,7 +407,7 @@ class Daum8i {
             incoming = bufferData;
         }
         const response = [...incoming];
-        this.logger.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(response) });
+        this.logger.logEvent({ message: 'sendCommand:RECV', data: utils_1.hexstr(response) });
         for (let i = 0; i < incoming.length; i++) {
             const getRemaining = () => {
                 let remaining = '';
@@ -439,11 +440,11 @@ class Daum8i {
             }
             else if (c === 0x17) {
                 const remaining = getRemaining();
-                this.logger.logEvent({ message: "sendCommand:received:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${(0, utils_1.hexstr)(cmd)}]`, remaining: (0, utils_1.hexstr)(remaining) });
+                this.logger.logEvent({ message: "sendCommand:received:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${utils_1.hexstr(cmd)}]`, remaining: utils_1.hexstr(remaining) });
                 this.state.waitingForEnd = false;
                 const cmdStr = cmd.substring(0, cmd.length - 2);
                 const checksumExtracted = cmd.slice(-2);
-                const checksumCalculated = (0, utils_1.checkSum)((0, utils_1.getAsciiArrayFromStr)(cmdStr), []);
+                const checksumCalculated = utils_1.checkSum(utils_1.getAsciiArrayFromStr(cmdStr), []);
                 if (checksumExtracted === checksumCalculated) {
                     this.sendACK();
                     if (this.state.sending && this.state.sending.responseCheckIv) {
@@ -485,8 +486,8 @@ class Daum8i {
                 this.state.busy = true;
             }
             else {
-                const message = (0, utils_1.buildMessage)(command, payload);
-                this.logger.logEvent({ message: 'sendCommand:waiting', port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
+                const message = utils_1.buildMessage(command, payload);
+                this.logger.logEvent({ message: 'sendCommand:waiting', port: this.portName, cmd: command, hex: utils_1.hexstr(message) });
                 const busyWait = () => {
                     return new Promise((done) => {
                         let start = Date.now();
@@ -507,7 +508,7 @@ class Daum8i {
                 };
                 const res = yield busyWait();
                 if (!res) {
-                    this.logger.logEvent({ message: 'sendCommand:busy timeout', port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message), duration: Date.now() - tsRequest });
+                    this.logger.logEvent({ message: 'sendCommand:busy timeout', port: this.portName, cmd: command, hex: utils_1.hexstr(message), duration: Date.now() - tsRequest });
                     return reject(new Error('BUSY timeout'));
                 }
                 this.state.busy = true;
@@ -525,10 +526,10 @@ class Daum8i {
             const portName = this.portName;
             this.state.received = [];
             try {
-                const message = (0, utils_1.buildMessage)(command, payload);
+                const message = utils_1.buildMessage(command, payload);
                 const start = Date.now();
                 const timeout = start + this.getTimeoutValue();
-                this.logger.logEvent({ message: "sendCommand:sending:", port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
+                this.logger.logEvent({ message: "sendCommand:sending:", port: this.portName, cmd: command, hex: utils_1.hexstr(message) });
                 this.state.writeBusy = true;
                 if (!this.connected || port === undefined) {
                     this.logger.logEvent({ message: "sendCommand:error: not connected", port: this.portName });
@@ -588,10 +589,10 @@ class Daum8i {
             buffer.writeUInt16LE(0, 2);
         }
         const cmdData = Uint8Array.from(buffer);
-        return this.sendDaum8iCommand('M70', cmdType, (0, utils_1.bin2esc)(cmdData))
+        return this.sendDaum8iCommand('M70', cmdType, utils_1.bin2esc(cmdData))
             .then((res) => {
             const resData = Uint8Array.from(res, x => x.charCodeAt(0));
-            const cmd = (0, utils_1.esc2bin)(resData);
+            const cmd = utils_1.esc2bin(resData);
             return cmd;
         });
     }
@@ -616,7 +617,7 @@ class Daum8i {
             else if (str === '7')
                 deviceType = 'lyps';
             else
-                throw (new Error(`unknown device type ${typeof str === 'string' ? (0, utils_1.ascii)(str.charAt(0)) : str}`));
+                throw (new Error(`unknown device type ${typeof str === 'string' ? utils_1.ascii(str.charAt(0)) : str}`));
             return deviceType;
         });
     }
@@ -631,7 +632,7 @@ class Daum8i {
             else if (str === '2')
                 deviceType = constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
             else {
-                throw (new Error(`unknown actual device type ${typeof str === 'string' ? (0, utils_1.ascii)(str.charAt(0)) : str}`));
+                throw (new Error(`unknown actual device type ${typeof str === 'string' ? utils_1.ascii(str.charAt(0)) : str}`));
             }
             this.state.actualBikeType = deviceType;
             return deviceType;
@@ -673,12 +674,12 @@ class Daum8i {
     getTrainingData() {
         return this.sendDaum8iCommand('X70', 'AF', [])
             .then((data) => {
-            const td = (0, utils_1.parseTrainingData)(data);
+            const td = utils_1.parseTrainingData(data);
             return td;
         });
     }
     setLoadControl(enabled) {
-        const val = enabled ? (0, utils_1.ascii)('1') : (0, utils_1.ascii)('0');
+        const val = enabled ? utils_1.ascii('1') : utils_1.ascii('0');
         return this.sendDaum8iCommand('S20', 'BF', [val])
             .then((data) => {
             const res = data === '1';
@@ -712,7 +713,7 @@ class Daum8i {
     setPerson(person) {
         const { sex, age, length, weight } = person;
         this.logger.logEvent({ message: 'setPerson() request', sex, age, length, weight });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PERSON_SET, 'BF', (0, utils_1.getPersonData)(person))
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PERSON_SET, 'BF', utils_1.getPersonData(person))
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PERSON_SET;
@@ -736,9 +737,10 @@ class Daum8i {
     }
     programUploadStart(bikeType, route) {
         const payload = Buffer.alloc(40);
-        const epp = route ? (0, utils_1.routeToEpp)(route) : undefined;
+        const epp = route ? utils_1.routeToEpp(route) : undefined;
         const eppLength = epp ? epp.length : 0;
-        const bikeTypeVal = (0, utils_1.getBikeType)(bikeType);
+        const bikeTypeVal = utils_1.getBikeType(bikeType);
+        const wBits = route.lapMode ? DS_BITS_ENDLESS_RACE : DS_BITS_OFF;
         payload.writeInt32LE(0, 0);
         payload.writeInt8(bikeTypeVal, 4);
         payload.writeInt8(0, 5);
@@ -750,7 +752,7 @@ class Daum8i {
         payload.writeInt16LE(0, 24);
         payload.writeInt16LE(0, 26);
         payload.writeInt16LE(0, 28);
-        payload.writeInt16LE(0, 30);
+        payload.writeInt16LE(wBits, 30);
         payload.writeInt32LE(7, 32);
         payload.writeInt32LE(eppLength, 36);
         this.logger.logEvent({ message: 'programUploadStart() request', bikeType, length: eppLength });

package/lib/daum/premium/utils.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPersonData = exports.parseTrainingData = exports.routeToEpp = exports.getBikeType = exports.BikeType = exports.ReservedCommands = exports.Int32ToIntArray = exports.Int16ToIntArray = exports.Float32ToIntArray = exports.Float32ToHex = exports.getAsciiArrayFromStr = exports.asciiArrayToString = exports.charArrayToString = exports.ascii = exports.append = exports.getHex = exports.hexstr = exports.getMessageData = exports.buildMessage = exports.checkSum = exports.esc2bin = exports.bin2esc = void 0;
 const win32filetime_1 = __importDefault(require("win32filetime"));
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);
 function bin2esc(arr) {

package/lib/kettler/comms.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { DeviceProtocol } from "../DeviceProtocol";
+import { EventLogger } from "gd-eventlog";
+import { Command } from "../types/command";
+import EventEmitter from "events";
+export declare type SerialCommsProps = {
+    logger?: EventLogger;
+    protocol: DeviceProtocol;
+    port: string;
+    settings?: any;
+};
+declare enum SerialCommsState {
+    Idle = 0,
+    Connecting = 1,
+    Connected = 2,
+    Disconnecting = 3,
+    Disconnected = 4,
+    Error = 5
+}
+export default class KettlerSerialComms<T extends Command> extends EventEmitter {
+    private logger;
+    private port;
+    private sp;
+    private queue;
+    private state;
+    private settings;
+    private worker;
+    private sendState;
+    private currentCmd;
+    private protocol;
+    constructor(opts: SerialCommsProps);
+    getPort(): string;
+    setPort(port: any): void;
+    isConnected(): boolean;
+    stateIn: (allowedStates: SerialCommsState[]) => boolean;
+    onPortOpen(): void;
+    onPortClose(): Promise<void>;
+    onPortError(err: any): void;
+    open(): void;
+    close(): void;
+    startWorker(): void;
+    stopWorker(): void;
+    onData(data: string | Buffer): void;
+    write(cmd: Command): void;
+    sendNextCommand(): Command | undefined;
+    send(cmd: Command): void;
+}
+export {};

package/lib/kettler/comms.js

@@ -0,0 +1,194 @@
+"use strict";
+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 gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../utils");
+const events_1 = __importDefault(require("events"));
+const DEFAULT_RCV_TIMEOUT = 500;
+const DEBUG_LOGGER = {
+    log: (e, ...args) => console.log(e, ...args),
+    logEvent: (event) => console.log(JSON.stringify(event))
+};
+var SerialCommsState;
+(function (SerialCommsState) {
+    SerialCommsState[SerialCommsState["Idle"] = 0] = "Idle";
+    SerialCommsState[SerialCommsState["Connecting"] = 1] = "Connecting";
+    SerialCommsState[SerialCommsState["Connected"] = 2] = "Connected";
+    SerialCommsState[SerialCommsState["Disconnecting"] = 3] = "Disconnecting";
+    SerialCommsState[SerialCommsState["Disconnected"] = 4] = "Disconnected";
+    SerialCommsState[SerialCommsState["Error"] = 5] = "Error";
+})(SerialCommsState || (SerialCommsState = {}));
+var SendState;
+(function (SendState) {
+    SendState[SendState["Idle"] = 0] = "Idle";
+    SendState[SendState["Sending"] = 1] = "Sending";
+    SendState[SendState["Receiving"] = 2] = "Receiving";
+})(SendState || (SendState = {}));
+const CRLF = '\r\n';
+class KettlerSerialComms extends events_1.default {
+    constructor(opts) {
+        super();
+        this.stateIn = (allowedStates) => {
+            return allowedStates.indexOf(this.state) >= 0;
+        };
+        this.logger = process.env.DEBUG ? DEBUG_LOGGER : (opts.logger || new gd_eventlog_1.EventLogger(opts.protocol.getName()));
+        this.port = opts.port || process.env.COM_PORT;
+        this.sp = undefined;
+        this.queue = new utils_1.Queue();
+        this.state = SerialCommsState.Idle;
+        this.sendState = SendState.Idle;
+        this.settings = opts.settings || {};
+        this.currentCmd = undefined;
+        this.protocol = opts.protocol;
+    }
+    getPort() {
+        return this.port;
+    }
+    setPort(port) {
+        this.port = port;
+    }
+    isConnected() {
+        return this.state === SerialCommsState.Connected;
+    }
+    onPortOpen() {
+        this.logger.logEvent({ message: 'port opened', port: this.getPort() });
+        this.state = SerialCommsState.Connected;
+        this.sendState = SendState.Idle;
+        this.startWorker();
+        this.emit('opened');
+    }
+    onPortClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'port closed', port: this.getPort() });
+            this.stopWorker();
+            if (this.sendState === SendState.Sending) {
+            }
+            this.state = SerialCommsState.Disconnected;
+            this.sendState = SendState.Idle;
+            this.queue.clear();
+            this.emit('closed');
+            this.sp.removeAllListeners();
+            this.sp = undefined;
+        });
+    }
+    onPortError(err) {
+        if (this.stateIn([SerialCommsState.Connected, SerialCommsState.Disconnected]))
+            return;
+        if (this.state === SerialCommsState.Disconnecting && (err.message === 'Port is not open' || err.message === 'Writing to COM port (GetOverlappedResult): Operation aborted'))
+            return;
+        if (this.state === SerialCommsState.Connecting && (err.message === 'Port is already open' || err.message === 'Port is opening'))
+            return;
+        this.logger.logEvent({ message: "port error:", port: this.getPort(), error: err.message, stack: err.stack, state: this.state });
+        this.emit('error', err);
+    }
+    open() {
+        this.logger.logEvent({ message: "open()", port: this.getPort() });
+        if (this.stateIn([SerialCommsState.Connected, SerialCommsState.Connecting, SerialCommsState.Disconnecting])) {
+            return;
+        }
+        try {
+            const SerialPort = this.protocol.getSerialPort();
+            if (this.sp === undefined) {
+                this.sp = new SerialPort(this.getPort(), this.settings);
+                this.sp.on('open', () => { this.onPortOpen(); });
+                this.sp.on('close', () => { this.onPortClose(); });
+                this.sp.on('error', (error) => { this.onPortError(error); });
+            }
+            this.state = SerialCommsState.Connecting;
+            const parser = this.sp.pipe(new SerialPort.parsers.Readline({ delimiter: CRLF }));
+            parser.on('data', (data) => { this.onData(data); });
+            this.sp.open();
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'open()', error: err.message });
+            this.state = SerialCommsState.Disconnected;
+        }
+    }
+    close() {
+        this.logger.logEvent({ message: 'close()', port: this.getPort() });
+        if (this.stateIn([SerialCommsState.Idle, SerialCommsState.Disconnected, SerialCommsState.Disconnecting])) {
+            return;
+        }
+        this.state = SerialCommsState.Disconnecting;
+        this.sp.close();
+    }
+    startWorker() {
+        this.worker = setInterval(() => {
+            this.sendNextCommand();
+        }, 50);
+    }
+    stopWorker() {
+        if (this.worker) {
+            clearInterval(this.worker);
+            this.worker = undefined;
+        }
+    }
+    onData(data) {
+        this.sendState = SendState.Idle;
+        this.currentCmd = undefined;
+        this.logger.logEvent({ message: "sendCommand:receiving:", data: data });
+        if (typeof data === 'string') {
+            if (data.length > 2)
+                data = data.trim();
+            this.currentCmd.onResponse(data);
+        }
+        else {
+            this.currentCmd.onResponse(data);
+        }
+    }
+    write(cmd) {
+        this.sendState = SendState.Sending;
+        const { logStr, message, timeout = (this.settings.timeout || DEFAULT_RCV_TIMEOUT) } = cmd;
+        const msg = typeof message === 'string' ? message : utils_1.hexstr(message);
+        const onError = (err) => {
+            this.logger.logEvent({ message: "sendCommand:error:", cmd: logStr, error: err.message, port: this.getPort() });
+            cmd.onError(err);
+            this.sendState = SendState.Idle;
+            this.currentCmd = undefined;
+        };
+        try {
+            this.logger.logEvent({ message: "sendCommand:sending:", cmd: logStr, msg, port: this.getPort() });
+            if (typeof (message) !== 'string')
+                throw new Error('message must be a string');
+            this.sp.write(msg + CRLF, (err) => {
+                this.sendState = SendState.Receiving;
+                this.currentCmd = cmd;
+                if (timeout) {
+                    setTimeout(() => {
+                        if (this.sendState === SendState.Receiving) {
+                            onError(new Error("timeout"));
+                        }
+                    }, timeout);
+                }
+                if (err)
+                    onError(err);
+            });
+        }
+        catch (err) {
+            onError(err);
+        }
+    }
+    sendNextCommand() {
+        if (this.sendState !== SendState.Idle) {
+            return;
+        }
+        const cmd = this.queue.dequeue();
+        if (cmd)
+            this.write(cmd);
+    }
+    send(cmd) {
+        this.queue.enqueue(cmd);
+    }
+}
+exports.default = KettlerSerialComms;

package/lib/kettler/ergo-racer/adapter.d.ts

@@ -0,0 +1,99 @@
+import { DeviceSettings } from "../../DeviceProtocol";
+import DeviceAdapterBase, { DeviceAdapter, DeviceData, Bike } from "../../Device";
+import { DeviceProtocol } from "../../DeviceProtocol";
+import { EventLogger } from "gd-eventlog";
+import { Command } from "../../types/command";
+import CyclingMode, { IncyclistBikeData } from "../../CyclingMode";
+import { User } from "../../types/user";
+export interface KettlerRacerCommand extends Command {
+}
+export interface KettlerExtendedBikeData {
+}
+export interface KettlerBikeData {
+    heartrate?: number;
+    cadence?: number;
+    speed?: number;
+    distance?: number;
+    requestedPower?: number;
+    energy?: number;
+    timestamp?: number;
+    time: number;
+    power: number;
+}
+export interface KettlerDeviceSettings extends DeviceSettings {
+    userSettings?: User;
+    bikeSettings?: any;
+    cyclingMode?: CyclingMode;
+}
+export default class KettlerRacerAdapter extends DeviceAdapterBase implements DeviceAdapter, Bike {
+    private id;
+    private settings;
+    private ignoreHrm;
+    private ignoreBike;
+    private ignorePower;
+    private logger;
+    private paused;
+    private comms;
+    private iv;
+    private requests;
+    private data;
+    private idata;
+    private kettlerData;
+    private updateBusy;
+    private requestBusy;
+    constructor(protocol: DeviceProtocol, settings: DeviceSettings);
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    setID(id: any): void;
+    getID(): string;
+    getName(): string;
+    getPort(): string;
+    setIgnoreHrm(ignore: boolean): void;
+    setIgnorePower(ignore: boolean): void;
+    setIgnoreBike(ignore: boolean): void;
+    getLogger(): EventLogger;
+    getUserSettings(): User;
+    getWeight(): number;
+    setComputerMode(): Promise<boolean>;
+    setClientMode(): Promise<boolean>;
+    reset(): Promise<boolean>;
+    getIdentifier(): Promise<string>;
+    getInterface(): Promise<string>;
+    getVersion(): Promise<string>;
+    getCalibration(): Promise<string>;
+    startTraining(): Promise<string>;
+    unknownSN(): Promise<string>;
+    setBaudrate(baudrate: number): Promise<string>;
+    setPower(power: number): Promise<string>;
+    getExtendedStatus(): Promise<KettlerExtendedBikeData>;
+    getStatus(): Promise<KettlerBikeData>;
+    getDB(): Promise<string>;
+    send(logStr: string, message: string, timeout?: any): Promise<any>;
+    parseExtendedStatus(data: string): KettlerExtendedBikeData;
+    parseStatus(data: string): KettlerBikeData;
+    check(): Promise<boolean>;
+    start(props?: any): Promise<any>;
+    startUpdatePull(): void;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    mapData(bikeData: KettlerBikeData): IncyclistBikeData;
+    transformData(internalData: IncyclistBikeData, bikeData: KettlerBikeData): DeviceData;
+    update(): Promise<void>;
+    sendRequest(request: any): Promise<any>;
+    sendRequests(): Promise<void>;
+    bikeSync(): Promise<void>;
+    sendUpdate(request: any): Promise<unknown>;
+    sendData(): void;
+    refreshRequests(): void;
+    processClientRequest(request: any): Promise<unknown>;
+    waitForOpened(): Promise<boolean>;
+    waitForClosed(): Promise<boolean>;
+    getSupportedCyclingModes(): any[];
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
+    setUserSettings(userSettings: any): void;
+    setBikeSettings(bikeSettings: any): void;
+}