incyclist-devices 2.0.38 → 2.1.1

package/lib/serial/types.d.ts

@@ -0,0 +1,45 @@
+import { EventLogger } from "gd-eventlog";
+import SerialInterface from "./base/serial-interface";
+import { BindingInterface } from "@serialport/bindings-interface";
+import { SerialPortStream } from "@serialport/stream";
+import { DeviceSettings, IncyclistScanProps, InterfaceProps } from "../types";
+export type SerialCommProps = {
+    serial: SerialInterface;
+    path: string;
+    logger?: EventLogger;
+};
+export type InterfaceBinding = {
+    name: string;
+    binding: BindingInterface;
+};
+export type InterfaceImplementation = {
+    name: string;
+    Serialport: any;
+    implementation?: any;
+};
+export type SerialPortProps = {
+    interface: string;
+    port?: string;
+};
+export declare enum SerialInterfaceType {
+    SERIAL = "serial",
+    TCPIP = "tcpip"
+}
+export interface SerialInterfaceProps extends InterfaceProps {
+    ifaceName: string;
+    binding?: BindingInterface;
+}
+export type PortMapping = {
+    path: string;
+    port: SerialPortStream;
+};
+export interface SerialScannerProps extends IncyclistScanProps {
+    port?: string;
+    protocol: string;
+}
+export interface SerialDeviceSettings extends DeviceSettings {
+    protocol: string;
+    host?: string;
+    port?: string;
+    interface: string | SerialInterface;
+}

package/lib/serial/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerialInterfaceType = void 0;
+var SerialInterfaceType;
+(function (SerialInterfaceType) {
+    SerialInterfaceType["SERIAL"] = "serial";
+    SerialInterfaceType["TCPIP"] = "tcpip";
+})(SerialInterfaceType || (exports.SerialInterfaceType = SerialInterfaceType = {}));
+;

package/lib/simulator/Simulator.d.ts

@@ -1,29 +1,29 @@
-import DeviceAdapter, { ControllableDevice } from '../base/adpater';
-import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { IncyclistBikeData } from '../modes/cycling-mode';
-import { DeviceProperties, DeviceSettings } from '../types/device';
+/// <reference types="node" />
+import SimulatorCyclingMode from '../modes/simulator';
+import IncyclistDevice from '../base/adpater';
+import { IAdapter, IncyclistBikeData, DeviceProperties, DeviceSettings } from '../types';
 interface SimulatorProperties extends DeviceProperties {
     isBot?: boolean;
     settings?: any;
     activity?: any;
 }
-export declare class Simulator extends ControllableDevice {
+export declare class Simulator extends IncyclistDevice<SimulatorProperties> {
     static NAME: string;
-    logger: EventLogger;
+    protected static controllers: {
+        modes: (typeof SimulatorCyclingMode)[];
+        default: typeof SimulatorCyclingMode;
+    };
     speed: number;
     power: number;
     cadence: number;
     time: number;
-    iv: any;
-    started: boolean;
     slope: number;
     limit: any;
     startProps?: any;
-    cyclingMode: CyclingMode;
     startTS: number;
     data: IncyclistBikeData;
     isBot: boolean;
-    ignoreHrm: boolean;
+    iv: NodeJS.Timeout;
     userSettings: {
         weight?: number;
     };
@@ -32,16 +32,10 @@ export declare class Simulator extends ControllableDevice {
     };
     constructor(settings: DeviceSettings, props?: SimulatorProperties);
     isEqual(settings: DeviceSettings): boolean;
-    isSame(device: DeviceAdapter): boolean;
+    isSame(device: IAdapter): boolean;
     getID(): string;
     getName(): string;
     getUniqueName(): string;
-    setIgnoreHrm(ignore: any): void;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
-    getCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    sendInitCommands(): Promise<boolean>;
     start(props?: SimulatorProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
@@ -50,8 +44,8 @@ export declare class Simulator extends ControllableDevice {
     faster(): void;
     slower(): void;
     update(): void;
-    canSendUpdate(): boolean;
+    canEmitData(): boolean;
     calculateDistance(speedKps: any, timeS: any): number;
-    sendUpdate(request: any): import("../modes/cycling-mode").UpdateRequest;
+    sendUpdate(request: any): import("..").UpdateRequest;
 }
 export {};

package/lib/simulator/Simulator.js

@@ -13,35 +13,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Simulator = void 0;
-const adpater_1 = require("../base/adpater");
 const gd_eventlog_1 = require("gd-eventlog");
 const simulator_1 = __importDefault(require("../modes/simulator"));
-const capabilities_1 = require("../types/capabilities");
+const adpater_1 = __importDefault(require("../base/adpater"));
+const types_1 = require("../types");
 const DEFAULT_PROPS = { isBot: false };
-class Simulator extends adpater_1.ControllableDevice {
+class Simulator extends adpater_1.default {
     constructor(settings, props = DEFAULT_PROPS) {
         super(settings, props);
         this.logger = new gd_eventlog_1.EventLogger(Simulator.NAME);
         this.speed = 0;
         this.power = 0;
         this.cadence = 90;
-        this.paused = undefined;
         this.time = undefined;
-        this.iv = undefined;
-        this.started = false;
-        this.paused = false;
         this.slope = 0;
         this.limit = {};
         this.startTS = undefined;
         this.data = { isPedalling: false, power: 0, pedalRpm: 0, speed: 0, heartrate: 0, distanceInternal: 0 };
         this.isBot = props.isBot || false;
-        this.ignoreHrm = false;
         const name = this.getCyclingMode().getName();
         const modeSettings = this.isBot ? props.settings : this.getCyclingMode().getSettings();
         this.setCyclingMode(name, modeSettings);
         this.capabilities = [
-            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Gear,
-            capabilities_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Gear,
+            types_1.IncyclistCapability.Control
         ];
     }
     isEqual(settings) {
@@ -55,44 +50,6 @@ class Simulator extends adpater_1.ControllableDevice {
     getID() { return Simulator.NAME; }
     getName() { return Simulator.NAME; }
     getUniqueName() { return Simulator.NAME; }
-    setIgnoreHrm(ignore) {
-        this.ignoreHrm = ignore;
-    }
-    getSupportedCyclingModes() {
-        const supported = [];
-        supported.push(simulator_1.default);
-        return supported;
-    }
-    getDefaultCyclingMode() {
-        return new simulator_1.default(this);
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
-    }
-    setCyclingMode(mode, settings) {
-        let selectedMode;
-        if (typeof mode === 'string') {
-            const supported = this.getSupportedCyclingModes();
-            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
-            if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
@@ -212,11 +169,9 @@ class Simulator extends adpater_1.ControllableDevice {
         if (this.isBot) {
             this.logger.logEvent(Object.assign({ message: 'Coach update', prevDist, prevTime }, data));
         }
-        if (this.ignoreHrm)
-            delete data.heartrate;
         this.emitData(data);
     }
-    canSendUpdate() {
+    canEmitData() {
         return true;
     }
     calculateDistance(speedKps, timeS) {
@@ -230,3 +185,7 @@ class Simulator extends adpater_1.ControllableDevice {
 }
 exports.Simulator = Simulator;
 Simulator.NAME = 'Simulator';
+Simulator.controllers = {
+    modes: [simulator_1.default],
+    default: simulator_1.default
+};

package/lib/types/Command.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export interface Command {
+    logStr?: string;
+    message: string | Buffer;
+    timeout?: number;
+    onError: (err: Error) => void;
+    onResponse: (response: string | Buffer) => void;
+}

package/lib/types/Command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/adapter.d.ts

@@ -1,41 +1,51 @@
 /// <reference types="node" />
 import EventEmitter from "events";
-import CyclingMode from "../modes/cycling-mode";
+import ICyclingMode, { CyclingMode } from "../modes/types";
 import { IncyclistCapability } from "./capabilities";
-import { DeviceData } from "./data";
+import { IncyclistAdapterData } from "./data";
 import { DeviceProperties, DeviceSettings } from "./device";
 import { User } from "./user";
-import { EventLogger } from "gd-eventlog";
-export type OnDeviceDataCallback = (data: DeviceData) => void;
-export interface IncyclistDeviceAdapter extends EventEmitter {
-    getLogger(): EventLogger;
-    connect(): Promise<boolean>;
-    close(): Promise<boolean>;
-    check(): Promise<boolean>;
-    isEqual(settings: DeviceSettings): boolean;
+export type OnDeviceDataCallback = (data: IncyclistAdapterData) => void;
+export type ControllerConfig = {
+    modes?: Array<typeof CyclingMode>;
+    default?: typeof CyclingMode;
+};
+export interface IBike {
+    setCyclingMode(mode: ICyclingMode | string, settings?: any, sendInitCommands?: boolean): void;
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getCyclingMode(): ICyclingMode;
+    getDefaultCyclingMode(): ICyclingMode;
+    setBikeProps(props: DeviceProperties): void;
+    sendInitCommands(): Promise<boolean>;
+    sendUpdate(request: any): any;
+    setUser(user: User): void;
+    getWeight(): number;
+    getUser(): User;
+}
+export interface ISensor {
+    isControllable(): boolean;
     getCapabilities(): IncyclistCapability[];
     hasCapability(capability: IncyclistCapability): boolean;
     addCapability(capability: IncyclistCapability): void;
-    isControllable(): boolean;
+    getMaxUpdateFrequency(): any;
+    setMaxUpdateFrequency(value: number): any;
+    update(): any;
+}
+export interface IAdapter extends EventEmitter, IBike, ISensor {
     getName(): string;
+    getID(): string;
     getUniqueName(): string;
-    getSettings(): DeviceSettings;
     getDisplayName(): string;
-    update(): any;
+    getSettings(): DeviceSettings;
+    isSame(adapter: IAdapter): boolean;
+    isEqual(settings: DeviceSettings): boolean;
+    getInterface(): string;
+    check(): Promise<boolean>;
     start(props?: DeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    sendUpdate(request: any): any;
-    getMaxUpdateFrequency(): any;
-    setMaxUpdateFrequency(value: number): any;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
     onData(callback: OnDeviceDataCallback): any;
 }
-export interface Bike {
-    setCyclingMode(mode: CyclingMode | string, settings?: any, sendInitCommands?: boolean): void;
-    getSupportedCyclingModes(): Array<any>;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
-    setBikeProps(props: DeviceProperties): void;
-    setUser(user: User): void;
-}

package/lib/types/command.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-export interface Command {
-    logStr?: string;
-    message: string | Buffer;
-    timeout?: number;
-    onError: (err: Error) => void;
-    onResponse: (response: string | Buffer) => void;
-}

package/lib/types/command.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/data.d.ts

@@ -1,4 +1,4 @@
-export type DeviceData = {
+export type IncyclistAdapterData = {
     speed?: number;
     slope?: number;
     power?: number;
@@ -10,3 +10,14 @@ export type DeviceData = {
     deviceDistanceCounter?: number;
     internalDistanceCounter?: number;
 };
+export type IncyclistBikeData = {
+    isPedalling?: boolean;
+    power: number;
+    pedalRpm: number;
+    speed: number;
+    heartrate?: number;
+    distanceInternal?: number;
+    time?: number;
+    gear?: number;
+    slope?: number;
+};

package/lib/types/device.d.ts

@@ -1,30 +1,15 @@
 import { EventLogger } from "gd-eventlog";
 import { IncyclistInterface } from "./interface";
 import { User } from "./user";
-export declare const INTERFACE: {
-    SERIAL: string;
-    TCPIP: string;
-    ANT: string;
-    BLE: string;
-    USB: string;
-    SIMULATOR: string;
-};
+export declare enum INTERFACE {
+    SERIAL = "serial",
+    TCPIP = "tcpip",
+    ANT = "ant",
+    BLE = "ble",
+    USB = "usb",
+    SIMULATOR = "simulator"
+}
 export type DeviceType = 'race' | 'mountain' | 'triathlon';
-export type Device = {
-    getID(): string;
-    getName(): string;
-    getInterface(): string;
-};
-export type DaumBikeData = {
-    cadence: number;
-    speed: number;
-    power: number;
-    heartrate: number;
-    distanceInternal: number;
-    gear: number;
-    time: number;
-    slope?: number;
-};
 export type DeviceProperties = {
     user?: User;
     userWeight?: number;

package/lib/types/device.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.INTERFACE = void 0;
-exports.INTERFACE = {
-    SERIAL: 'serial',
-    TCPIP: 'tcpip',
-    ANT: 'ant',
-    BLE: 'ble',
-    USB: 'usb',
-    SIMULATOR: 'simulator'
-};
+var INTERFACE;
+(function (INTERFACE) {
+    INTERFACE["SERIAL"] = "serial";
+    INTERFACE["TCPIP"] = "tcpip";
+    INTERFACE["ANT"] = "ant";
+    INTERFACE["BLE"] = "ble";
+    INTERFACE["USB"] = "usb";
+    INTERFACE["SIMULATOR"] = "simulator";
+})(INTERFACE || (exports.INTERFACE = INTERFACE = {}));

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './adapter';
+export * from './capabilities';
+export * from './data';
+export * from './device';
+export * from './interface';
+export * from './user';

package/lib/types/index.js

@@ -0,0 +1,22 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapter"), exports);
+__exportStar(require("./capabilities"), exports);
+__exportStar(require("./data"), exports);
+__exportStar(require("./device"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./user"), exports);

package/lib/types/route.d.ts

@@ -1,19 +0,0 @@
-export type Point = {
-    lat?: number;
-    lng?: number;
-    elevation?: number;
-    distance: number;
-    slope?: number;
-};
-export type Route = {
-    programId: number;
-    points: Point[];
-    type: string;
-    name?: string;
-    description?: string;
-    lapMode: boolean;
-    totalDistance: number;
-    minElevation?: number;
-    maxElevation?: number;
-    sampleRate?: number;
-};

package/lib/types/route.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/types.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export interface Command {
+    logStr?: string;
+    message: string | Buffer;
+    timeout?: number;
+    onError: (err: Error) => void;
+    onResponse: (response: string | Buffer) => void;
+}

package/lib/types/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/utils.d.ts

@@ -1,6 +1,6 @@
 export declare const sleep: (ms: any) => Promise<unknown>;
 export declare const resolveNextTick: () => Promise<void>;
-export declare function runWithRetries(fn: any, maxRetries: any, timeBetween: any): Promise<unknown>;
+export declare function runWithRetries(fn: any, maxRetries: any, timeBetween: any): Promise<any>;
 export declare function floatVal(d?: number | string): number;
 export declare function intVal(d?: number | string): number;
 export declare function hexstr(arr: any, start?: any, len?: any): string;
@@ -13,4 +13,5 @@ export declare class Queue<T> {
     dequeue(): T;
     enqueue(value: T): void;
 }
+export declare function runWithTimeout(promise: Promise<any>, timeout: number): Promise<any>;
 export declare function waitWithTimeout(promise: Promise<any>, timeout: number, onTimeout?: () => void): Promise<any>;

package/lib/utils/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitWithTimeout = exports.Queue = exports.hexstr = exports.intVal = exports.floatVal = exports.runWithRetries = exports.resolveNextTick = exports.sleep = void 0;
+exports.waitWithTimeout = exports.runWithTimeout = exports.Queue = exports.hexstr = exports.intVal = exports.floatVal = exports.runWithRetries = exports.resolveNextTick = exports.sleep = void 0;
 const sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
@@ -116,7 +116,19 @@ class Queue {
     }
 }
 exports.Queue = Queue;
+function runWithTimeout(promise, timeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield doWaitWithTimeout(promise, timeout, true);
+    });
+}
+exports.runWithTimeout = runWithTimeout;
 function waitWithTimeout(promise, timeout, onTimeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield doWaitWithTimeout(promise, timeout, false, onTimeout);
+    });
+}
+exports.waitWithTimeout = waitWithTimeout;
+function doWaitWithTimeout(promise, timeout, throwError, onTimeout) {
     return __awaiter(this, void 0, void 0, function* () {
         let to;
         let hasTimedOut = false;
@@ -124,7 +136,7 @@ function waitWithTimeout(promise, timeout, onTimeout) {
             return new Promise((resolve, reject) => {
                 to = setTimeout(() => {
                     hasTimedOut = true;
-                    if (!onTimeout) {
+                    if (!onTimeout || throwError) {
                         reject(new Error('Timeout'));
                     }
                     else {
@@ -144,11 +156,17 @@ function waitWithTimeout(promise, timeout, onTimeout) {
             res = yield Promise.race([promise, toPromise(timeout)]);
         }
         catch (err) {
-            if (err.message === 'Timeout' && hasTimedOut)
+            if (err.message === 'Timeout' && hasTimedOut) {
                 throw err;
+            }
+            else {
+                if (throwError) {
+                    clearTimeout(to);
+                    throw err;
+                }
+            }
         }
         clearTimeout(to);
         return res;
     });
 }
-exports.waitWithTimeout = waitWithTimeout;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.0.38",
+  "version": "2.1.1",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",
@@ -27,8 +27,8 @@
   "scripts": {
     "lint": "eslint . --ext .ts",
     "build": "tsc",
-    "test": "jest --coverage",
-    "test:ci": "jest --coverage --forceExit",
+    "test": "npx jest --coverage",
+    "test:ci": "npx jest --coverage --forceExit",
     "dev": "tsc --watch",
     "postversion": "git push && git push --tags"
   },

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

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

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

@@ -1,51 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
-const MAX_DEVIATION = 10;
-class AntAdvSimCyclingMode extends ble_st_mode_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.initLogger('AntAdvSimMode');
-    }
-    getName() {
-        return 'Advanced Smart Trainer';
-    }
-    getDescription() {
-        return 'Sends Slope to device. Respects Limits (from workout or settings). Calculates speed based on power and slope. ';
-    }
-    sendBikeUpdate(request) {
-        const getData = () => {
-            if (!this.data)
-                return {};
-            const { gear, pedalRpm, slope, power, speed } = this.data;
-            return { gear, pedalRpm, slope, power, speed };
-        };
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
-        let newRequest = {};
-        if (request.slope === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
-            return this.prevRequest;
-        }
-        if (request.slope !== undefined) {
-            newRequest.slope = parseFloat(request.slope.toFixed(1));
-            this.data.slope = newRequest.slope;
-        }
-        if (this.data && this.data.power) {
-            const { minPower, maxPower } = request;
-            let { targetPower } = request;
-            if (minPower !== undefined && maxPower !== undefined && minPower === maxPower)
-                targetPower = maxPower;
-            if (targetPower !== undefined && Math.abs(this.data.power - targetPower) > MAX_DEVIATION)
-                newRequest.targetPower = targetPower;
-            else if (minPower !== undefined && this.data.power < minPower)
-                newRequest.targetPower = minPower;
-            else if (request.maxPower !== undefined && this.data.power > request.maxPower)
-                newRequest.targetPower = maxPower;
-        }
-        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
-        return newRequest;
-    }
-}
-exports.default = AntAdvSimCyclingMode;

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

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