incyclist-devices 2.0.35 → 2.0.36

package/lib/antv2/modes/ant-fe-adv-st-mode.d.ts

@@ -1,8 +1,8 @@
+import { ControllableDeviceAdapter } from "../..";
 import FtmsCyclingMode from "../../modes/ble-st-mode";
 import { UpdateRequest } from "../../modes/cycling-mode";
-import { IncyclistDeviceAdapter } from "../../types/adapter";
 export default class AntAdvSimCyclingMode extends FtmsCyclingMode {
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: ControllableDeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     sendBikeUpdate(request: UpdateRequest): UpdateRequest;

package/lib/antv2/modes/ant-fe-erg-mode.d.ts

@@ -1,6 +1,6 @@
+import { ControllableDeviceAdapter } from "../..";
 import BleERGCyclingMode from "../../modes/ble-erg-mode";
-import { IncyclistDeviceAdapter } from "../../types/adapter";
 export default class AntFeERGCyclingMode extends BleERGCyclingMode {
     static isERG: boolean;
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: ControllableDeviceAdapter, props?: any);
 }

package/lib/antv2/modes/ant-fe-st-mode.d.ts

@@ -1,5 +1,5 @@
+import { ControllableDeviceAdapter } from "../..";
 import FtmsCyclingMode from "../../modes/ble-st-mode";
-import { IncyclistDeviceAdapter } from "../../types/adapter";
 export default class AntStCyclingMode extends FtmsCyclingMode {
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: ControllableDeviceAdapter, props?: any);
 }

package/lib/base/adpater.d.ts

@@ -25,6 +25,7 @@ export default class IncyclistDevice extends EventEmitter implements IncyclistDe
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     check(): Promise<boolean>;
+    getLogger(): EventLogger;
     isControllable(): boolean;
     isEqual(settings: DeviceSettings): boolean;
     getCapabilities(): IncyclistCapability[];
@@ -60,10 +61,10 @@ export declare class ControllableDevice extends IncyclistDevice implements Bike
     isControllable(): boolean;
     setUser(user: User): void;
     setBikeProps(props: DeviceProperties): void;
-    getWeight(): number;
     getSupportedCyclingModes(): any[];
     getDefaultCyclingMode(): CyclingMode;
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;
     sendInitCommands(): Promise<boolean>;
     getCyclingMode(): CyclingMode;
+    getWeight(): number;
 }

package/lib/base/adpater.js

@@ -34,6 +34,7 @@ class IncyclistDevice extends events_1.default {
     connect() { throw new Error('not implemented'); }
     close() { throw new Error('not implemented'); }
     check() { throw new Error("Method not implemented."); }
+    getLogger() { return undefined; }
     isControllable() {
         return false;
     }
@@ -154,12 +155,6 @@ class ControllableDevice extends IncyclistDevice {
                 this.props[k] = p;
         });
     }
-    getWeight() {
-        const { user = {}, props = exports.DEFAULT_PROPS } = this;
-        const userWeight = user.weight || props.userWeight || exports.DEFAULT_USER_WEIGHT;
-        const bikeWeight = props.bikeWeight || exports.DEFAULT_BIKE_WEIGHT;
-        return userWeight + bikeWeight;
-    }
     getSupportedCyclingModes() { throw new Error('not implemented'); }
     getDefaultCyclingMode() { throw new Error('not implemented'); }
     setCyclingMode(mode, settings) {
@@ -189,5 +184,11 @@ class ControllableDevice extends IncyclistDevice {
             this.setCyclingMode(this.getDefaultCyclingMode());
         return this.cyclingMode;
     }
+    getWeight() {
+        const { user = {}, props = exports.DEFAULT_PROPS } = this;
+        const userWeight = user.weight || props.userWeight || exports.DEFAULT_USER_WEIGHT;
+        const bikeWeight = props.bikeWeight || exports.DEFAULT_BIKE_WEIGHT;
+        return userWeight + bikeWeight;
+    }
 }
 exports.ControllableDevice = ControllableDevice;

package/lib/interfaces.d.ts

@@ -3,5 +3,5 @@ import { SerialInterface } from "./serial";
 import AntInterface from "./antv2/ant-interface";
 import { BleInterface } from "./ble";
 export default class InterfaceFactory {
-    static create(ifaceName: string, props?: InterfaceProps): AntInterface | BleInterface | SerialInterface;
+    static create(ifaceName: string, props?: InterfaceProps): SerialInterface | BleInterface | AntInterface;
 }

package/lib/modes/ble-erg-mode.d.ts

@@ -1,4 +1,4 @@
-import { IncyclistDeviceAdapter } from "../types/adapter";
+import { ControllableDeviceAdapter } from "..";
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "./cycling-mode";
 import PowerBasedCyclingModeBase from "./power-base";
 export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
@@ -7,7 +7,7 @@ export default class BleERGCyclingMode extends PowerBasedCyclingModeBase impleme
     hasBikeUpdate: boolean;
     chain: number[];
     cassette: number[];
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: ControllableDeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/modes/ble-st-mode.d.ts

@@ -1,10 +1,10 @@
+import { ControllableDeviceAdapter } from "..";
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../modes/cycling-mode";
 import PowerBasedCyclingModeBase from "../modes/power-base";
-import { IncyclistDeviceAdapter } from "../types/adapter";
 export default class FtmsCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: ControllableDeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/modes/cycling-mode.d.ts

@@ -1,4 +1,4 @@
-import { IncyclistDeviceAdapter } from "../types/adapter";
+import { ControllableDeviceAdapter } from "..";
 export type UpdateRequest = {
     slope?: number;
     minPower?: number;
@@ -28,12 +28,12 @@ export type CyclingModeProperty = {
     options?: any[];
 };
 export type IncyclistBikeData = {
-    isPedalling: boolean;
+    isPedalling?: boolean;
     power: number;
     pedalRpm: number;
     speed: number;
-    heartrate: number;
-    distanceInternal: number;
+    heartrate?: number;
+    distanceInternal?: number;
     time?: number;
     gear?: number;
     slope?: number;
@@ -57,11 +57,11 @@ export default interface CyclingMode {
     getModeProperty(name: string): any;
 }
 export declare class CyclingModeBase implements CyclingMode {
-    adapter: IncyclistDeviceAdapter;
+    adapter: ControllableDeviceAdapter;
     settings: Settings;
     properties: Settings;
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
-    setAdapter(adapter: IncyclistDeviceAdapter): void;
+    constructor(adapter: ControllableDeviceAdapter, props?: any);
+    setAdapter(adapter: ControllableDeviceAdapter): void;
     getBikeInitRequest(): UpdateRequest;
     getName(): string;
     getDescription(): string;

package/lib/modes/power-base.d.ts

@@ -1,13 +1,13 @@
 import { IncyclistBikeData, Settings, CyclingModeBase } from './cycling-mode';
 import { EventLogger } from 'gd-eventlog';
-import { IncyclistDeviceAdapter } from '../types/adapter';
+import { ControllableDeviceAdapter } from '..';
 export default class PowerBasedCyclingModeBase extends CyclingModeBase {
     data: IncyclistBikeData;
     prevUpdateTS: number;
     logger: EventLogger;
-    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
     initLogger(defaultLogName: any): void;
-    getWeight(): any;
+    getWeight(): number;
     getTimeSinceLastUpdate(): number;
     calculateSpeedAndDistance(power: number, slope: number, m: number, t: number, props?: {}): {
         speed: number;

package/lib/modes/power-base.js

@@ -15,13 +15,14 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
     }
     initLogger(defaultLogName) {
         const a = this.adapter;
-        this.logger = (a && a.getLogger) ? a.getLogger() : undefined;
+        this.logger = a.getLogger();
         if (!this.logger)
             this.logger = new gd_eventlog_1.EventLogger(defaultLogName);
     }
     getWeight() {
         const a = this.adapter;
-        const m = (a && a.getWeight && a.getWeight()) ? a.getWeight() : adpater_1.DEFAULT_BIKE_WEIGHT + adpater_1.DEFAULT_USER_WEIGHT;
+        const defaultWeight = adpater_1.DEFAULT_BIKE_WEIGHT + adpater_1.DEFAULT_USER_WEIGHT;
+        const m = (a) ? a.getWeight() || defaultWeight : defaultWeight;
         return m;
     }
     getTimeSinceLastUpdate() {

package/lib/modes/power-meter.d.ts

@@ -1,13 +1,13 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from '../modes/cycling-mode';
 import PowerBasedCyclingModeBase from './power-base';
-import { IncyclistDeviceAdapter } from '../types/adapter';
+import { ControllableDeviceAdapter } from '..';
 export declare const config: {
     name: string;
     description: string;
     properties: any[];
 };
 export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/serial/comms.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { EventLogger } from "gd-eventlog";
+import SerialInterface from "./serial-interface";
+import { SerialCommProps } from "./comm";
+import { SerialPortStream } from "@serialport/stream";
+import { Queue } from "../utils/utils";
+export type ConnectionState = 'Connecting' | 'Connected' | 'Disconnected' | 'Disconnecting';
+export type Request = {
+    logString?: string;
+    isBinary?: boolean;
+};
+export type Response = {};
+export interface CommsState {
+    data?: Queue<Response>;
+}
+export default class SerialPortComms<T extends CommsState, C extends Request, R extends Response> {
+    logger: EventLogger;
+    serial: SerialInterface;
+    protected path: string;
+    protected props: SerialCommProps;
+    protected sp: SerialPortStream;
+    protected connectState: ConnectionState;
+    protected connectPromise: Promise<SerialPortStream>;
+    protected disconnectPromise: Promise<boolean>;
+    protected writePromise: Promise<void>;
+    protected sendCmdPromise: Promise<R>;
+    protected actualBikeType?: string;
+    protected recvState: T;
+    protected isLoggingPaused: boolean;
+    constructor(props: SerialCommProps);
+    getBusyTimeout(): number;
+    getDefaultLoggerName(): string;
+    getInitialCommsState(): T;
+    validatePath(path: string): string;
+    getInterface(): string;
+    getPort(): string;
+    isConnected(): boolean;
+    pauseLogging(): void;
+    resumeLogging(): void;
+    logEvent(e: any): void;
+    connect(): Promise<boolean>;
+    onConnected(): void;
+    portFlush(): void;
+    portPipe(destination: any, options?: any): any;
+    portUnpipe(destination?: any): void;
+    closePort(): Promise<boolean>;
+    resetState(isDisconnected?: boolean): void;
+    cleanupPort(isDisconnected?: boolean): void;
+    close(): Promise<boolean>;
+    flush(): Promise<void>;
+    onPortClose(): Promise<void>;
+    onPortError(error: Error): Promise<void>;
+    isSending(): boolean;
+    rejectCurrent(error: Error): void;
+    getTimeoutValue(): number;
+    onData(data: any, depth?: number): Promise<void>;
+    send(command: C): Promise<R>;
+    portWrite(buffer: Buffer): Promise<void>;
+    write(buffer: Buffer): Promise<void>;
+    ensurePrevCmdFinish(logPayload: any): Promise<void>;
+    ensureConnection(): Promise<void>;
+}

package/lib/serial/comms.js

@@ -0,0 +1,280 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("./daum/premium/utils");
+const utils_2 = require("../utils/utils");
+const DEFAULT_BUSY_TIMEOUT = 5000;
+class SerialPortComms {
+    constructor(props) {
+        this.props = props;
+        const { logger, serial, path } = props;
+        this.serial = serial;
+        this.path = this.validatePath(path);
+        const w = global.window;
+        this.logger = logger || ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.DEBUG ? utils_1.DEBUG_LOGGER : new gd_eventlog_1.EventLogger(this.getDefaultLoggerName()));
+        this.resetState();
+    }
+    getBusyTimeout() {
+        return DEFAULT_BUSY_TIMEOUT;
+    }
+    getDefaultLoggerName() {
+        return 'Serial';
+    }
+    getInitialCommsState() {
+        return { data: new utils_2.Queue() };
+    }
+    validatePath(path) {
+        return path;
+    }
+    getInterface() {
+        var _a;
+        return (_a = this.serial) === null || _a === void 0 ? void 0 : _a.ifaceName;
+    }
+    getPort() {
+        return this.path;
+    }
+    isConnected() {
+        return this.connectState === 'Connected' || this.connectState === 'Disconnecting';
+    }
+    pauseLogging() {
+        this.isLoggingPaused = true;
+    }
+    resumeLogging() {
+        this.isLoggingPaused = false;
+    }
+    logEvent(e) {
+        if (this.isLoggingPaused)
+            return;
+        this.logger.logEvent(e);
+        const w = global.window;
+        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
+            console.log(`~~~ ${this.getDefaultLoggerName()}`, e);
+        }
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected() && this.sp) {
+                return true;
+            }
+            if (this.connectState === 'Connecting') {
+                if (this.connectPromise) {
+                    try {
+                        yield this.connectPromise;
+                    }
+                    catch (_a) {
+                    }
+                }
+                return this.isConnected();
+            }
+            try {
+                this.connectState = 'Connecting';
+                this.connectPromise = this.serial.openPort(this.path);
+                const port = yield this.connectPromise;
+                this.connectPromise = null;
+                if (port !== null) {
+                    this.connectState = 'Connected';
+                    this.sp = port;
+                    this.sp.on('close', this.onPortClose.bind(this));
+                    this.sp.on('error', this.onPortError.bind(this));
+                    this.onConnected();
+                    return true;
+                }
+                else {
+                    this.connectState = 'Disconnected';
+                    return false;
+                }
+            }
+            catch (_b) {
+                this.connectState = 'Disconnected';
+                return false;
+            }
+        });
+    }
+    onConnected() {
+    }
+    portFlush() {
+        if (this.sp)
+            this.sp.flush();
+    }
+    portPipe(destination, options) {
+        if (this.sp)
+            return this.sp.pipe(destination, options);
+    }
+    portUnpipe(destination) {
+        if (this.sp)
+            this.sp.unpipe(destination);
+    }
+    closePort() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sp)
+                return true;
+            try {
+                yield this.flush();
+                yield this.serial.closePort(this.path);
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not close ', reason: err.message });
+                return false;
+            }
+        });
+    }
+    resetState(isDisconnected = true) {
+        this.isLoggingPaused = false;
+        this.recvState = this.getInitialCommsState();
+        this.connectPromise = null;
+        this.disconnectPromise = null;
+        this.writePromise = null;
+        this.sendCmdPromise = null;
+        if (isDisconnected)
+            this.connectState = 'Disconnected';
+    }
+    cleanupPort(isDisconnected = true) {
+        if (this.sp) {
+            this.sp.removeAllListeners();
+        }
+        this.sp = null;
+        this.resetState(isDisconnected);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let isDisconnected = false;
+            if (this.disconnectPromise) {
+                try {
+                    isDisconnected = yield this.disconnectPromise;
+                }
+                catch (_a) {
+                }
+                return isDisconnected;
+            }
+            if (this.connectState === 'Disconnected') {
+                this.cleanupPort();
+                return true;
+            }
+            else if (this.connectState === 'Disconnecting' || this.connectState === 'Connected' || this.connectState === 'Connecting') {
+                this.connectState = 'Disconnecting';
+                this.disconnectPromise = this.closePort();
+                isDisconnected = yield this.disconnectPromise;
+                if (isDisconnected) {
+                    this.connectState = 'Disconnected';
+                    this.logEvent({ message: "port closed:", port: this.path });
+                }
+                this.cleanupPort(isDisconnected);
+            }
+            return isDisconnected;
+        });
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.writePromise) {
+                yield (0, utils_2.waitWithTimeout)(this.writePromise, 1000);
+                this.writePromise = null;
+            }
+        });
+    }
+    onPortClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connectState !== 'Disconnected' && this.connectState !== 'Disconnecting')
+                this.logEvent({ message: "port closed:", port: this.path });
+            this.connectState = 'Disconnected';
+            this.cleanupPort();
+        });
+    }
+    onPortError(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connectState === 'Disconnecting' || this.connectState === 'Disconnected') {
+                return;
+            }
+            this.logEvent({ message: "port error:", port: this.path, error: error.message, connected: this.isConnected(), state: this.connectState });
+            if (this.isSending()) {
+                this.rejectCurrent(error);
+            }
+            if (this.connectState === 'Connected')
+                this.close();
+        });
+    }
+    isSending() {
+        return (this.writePromise !== undefined && this.writePromise !== null) || (this.sendCmdPromise !== null && this.sendCmdPromise !== undefined);
+    }
+    rejectCurrent(error) {
+        this.recvState.data.enqueue({ type: 'Error', error });
+    }
+    getTimeoutValue() {
+        throw new Error('method not implemented');
+    }
+    onData(data, depth = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    send(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('method not implemented');
+        });
+    }
+    portWrite(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sp) {
+                this.logEvent({ message: 'write failed', error: 'port is not opened' });
+                return;
+            }
+            try {
+                yield this.sp.write(buffer);
+            }
+            catch (err) {
+                this.logEvent({ message: 'write failed', error: err.message });
+            }
+        });
+    }
+    write(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.writePromise) {
+                try {
+                    yield this.writePromise;
+                }
+                catch (_a) {
+                }
+                this.writePromise = null;
+            }
+            this.writePromise = this.portWrite(buffer);
+            yield this.writePromise;
+            this.writePromise = null;
+        });
+    }
+    ensurePrevCmdFinish(logPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sendCmdPromise) {
+                const tsRequest = Date.now();
+                this.logEvent(Object.assign({ message: 'sendCommand:waiting:' }, logPayload));
+                let busyTimedOut = false;
+                const onTimeout = () => {
+                    this.logEvent(Object.assign(Object.assign({ message: 'sendCommand:error:' }, logPayload), { error: 'BUSY timeout', duration: Date.now() - tsRequest }));
+                    busyTimedOut = true;
+                };
+                yield (0, utils_2.waitWithTimeout)(this.sendCmdPromise, this.getBusyTimeout(), onTimeout);
+                this.sendCmdPromise = null;
+                if (busyTimedOut)
+                    throw new Error('BUSY timeout');
+            }
+        });
+    }
+    ensureConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                const connected = yield this.connect();
+                if (!connected) {
+                    throw new Error('not connected');
+                }
+            }
+        });
+    }
+}
+exports.default = SerialPortComms;

package/lib/serial/daum/DaumAdapter.d.ts

@@ -4,10 +4,13 @@ import { Bike } from '../../types/adapter';
 import { DeviceProperties } from '../../types/device';
 import { SerialDeviceSettings, SerialIncyclistDevice } from '../adapter';
 import { DeviceData } from '../../types/data';
-interface DaumAdapter {
-    getCurrentBikeData(): Promise<any>;
+export interface IDaumAdapter {
+    getCurrentBikeData(): Promise<IncyclistBikeData>;
 }
-export default class DaumAdapterBase extends SerialIncyclistDevice implements DaumAdapter, Bike {
+export declare abstract class AbstractDaumAdapter extends SerialIncyclistDevice implements IDaumAdapter {
+    abstract getCurrentBikeData(): Promise<any>;
+}
+export default class DaumAdapter<S extends SerialDeviceSettings, P extends DeviceProperties> extends AbstractDaumAdapter implements Bike {
     bike: any;
     ignoreHrm: boolean;
     ignoreBike: boolean;
@@ -25,35 +28,37 @@ export default class DaumAdapterBase extends SerialIncyclistDevice implements Da
     adapterTime: number;
     requestBusy: boolean;
     updateBusy: boolean;
-    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
+    constructor(settings: S, props?: P);
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;
     sendInitCommands(): Promise<boolean>;
     getSupportedCyclingModes(): Array<any>;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
-    getCurrentBikeData(): Promise<any>;
+    getCurrentBikeData(): Promise<IncyclistBikeData>;
     getBike(): any;
     isEqual(settings: SerialDeviceSettings): boolean;
     isSame(device: SerialIncyclistDevice): boolean;
     isStopped(): boolean;
     initData(): void;
-    start(props?: DeviceProperties): Promise<any>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    start(props?: P): Promise<any>;
     stopUpdatePull(): void;
     startUpdatePull(): void;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     logEvent(event: any): void;
+    reconnect(): Promise<boolean>;
     stop(): Promise<boolean>;
     canSendUpdate(): boolean;
     sendUpdate(request: any): Promise<unknown>;
     update(): Promise<void>;
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
-    updateData(prev: any, bikeData: any): IncyclistBikeData;
+    updateData(bikeData: IncyclistBikeData): IncyclistBikeData;
     transformData(cyclingData: IncyclistBikeData): DeviceData;
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
     check(): Promise<boolean>;
 }
-export {};