incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/adapters.d.ts

@@ -0,0 +1,6 @@
+import { IncyclistDeviceAdapter } from "./types/adapter";
+import { DeviceProperties, DeviceSettings } from "./types/device";
+export default class AdapterFactory {
+    static adapters: IncyclistDeviceAdapter[];
+    static create(settings: DeviceSettings, props?: DeviceProperties): any;
+}

package/lib/adapters.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antv2_1 = require("./antv2");
+const serial_1 = require("./serial");
+const device_1 = require("./types/device");
+class AdapterFactory {
+    static create(settings, props) {
+        const adapters = AdapterFactory.adapters;
+        const existing = adapters.find(a => a.isEqual(settings));
+        if (existing)
+            return existing;
+        const ifaceName = typeof settings.interface === 'string' ? settings.interface : settings.interface.getName();
+        let adapter;
+        switch (ifaceName) {
+            case device_1.INTERFACE.SERIAL:
+            case device_1.INTERFACE.TCPIP:
+                adapter = serial_1.SerialAdapterFactory.getInstance().createInstance(settings, props);
+                break;
+            case device_1.INTERFACE.ANT:
+                adapter = antv2_1.AntAdapterFactory.getInstance().createInstance(settings, props);
+                break;
+        }
+        if (adapter) {
+            adapters.push(adapter);
+        }
+        return adapter;
+    }
+}
+exports.default = AdapterFactory;
+AdapterFactory.adapters = [];

package/lib/antv2/adapter-factory.d.ts

@@ -1,11 +1,21 @@
-import AntProtocol, { AntDeviceSettings } from "./incyclist-protocol";
-import AntAdapter from "./ant-device";
-export default class AdapterFactory {
-    static create(settings: {
-        configuration?: AntDeviceSettings;
-        detected?: {
-            profile: string;
-            deviceID: number;
-        };
-    }, protocol: AntProtocol): AntAdapter;
+import AntAdapter from "./adapter";
+import { AntDeviceProperties, AntDeviceSettings } from "./types";
+export type AntAdapterInfo = {
+    antProfile: string;
+    incyclistProfile: string;
+    Adapter: typeof AntAdapter;
+};
+export type AdapterQuery = {
+    antProfile?: string;
+    incyclistProfile?: string;
+};
+export default class AntAdapterFactory {
+    static _instance: AntAdapterFactory;
+    adapters: AntAdapterInfo[];
+    static getInstance(): AntAdapterFactory;
+    constructor();
+    register(antProfile: string, incyclistProfile: string, Adapter: typeof AntAdapter): void;
+    getAdapter(query?: AdapterQuery): any;
+    createInstance(settings: AntDeviceSettings, props?: AntDeviceProperties): any;
+    createFromDetected(profile: string, deviceID: number, props?: AntDeviceProperties): any;
 }

package/lib/antv2/adapter-factory.js

@@ -1,40 +1,56 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const incyclist_protocol_1 = require("./incyclist-protocol");
-const fe_1 = __importDefault(require("./fe"));
-const hr_1 = __importDefault(require("./hr"));
-const pwr_1 = __importDefault(require("./pwr"));
-const sensor_factory_1 = __importDefault(require("./sensor-factory"));
-const profiles = [
-    { profile: 'PWR', Class: pwr_1.default },
-    { profile: 'HR', Class: hr_1.default },
-    { profile: 'FE', Class: fe_1.default },
-];
-class AdapterFactory {
-    static create(settings, protocol) {
-        let profile;
-        let deviceID;
-        if (settings && settings.configuration) {
-            profile = (0, incyclist_protocol_1.mapIncyclistProfile)(settings.configuration.profile);
-            deviceID = settings.configuration.deviceID;
-        }
-        else if (settings && settings.detected) {
-            profile = settings.detected.profile;
-            deviceID = settings.detected.deviceID;
+class AntAdapterFactory {
+    static getInstance() {
+        if (!AntAdapterFactory._instance)
+            AntAdapterFactory._instance = new AntAdapterFactory();
+        return AntAdapterFactory._instance;
+    }
+    constructor() {
+        this.adapters = [];
+    }
+    register(antProfile, incyclistProfile, Adapter) {
+        const info = Object.assign({}, { antProfile, incyclistProfile, Adapter });
+        const existing = this.adapters.findIndex(a => a.antProfile === antProfile);
+        if (existing !== -1)
+            this.adapters[existing] = info;
+        else
+            this.adapters.push(info);
+    }
+    getAdapter(query) {
+        const { antProfile, incyclistProfile } = query;
+        if (!antProfile && !incyclistProfile)
+            throw new Error('Illegal arguments: either "antProfile" or "incyclistProfile" must be set');
+        let found;
+        if (antProfile)
+            found = this.adapters.find(a => a.antProfile === antProfile);
+        if (incyclistProfile)
+            found = this.adapters.find(a => a.incyclistProfile === incyclistProfile);
+        return found;
+    }
+    createInstance(settings, props) {
+        let info;
+        const { profile, protocol } = settings;
+        if (protocol) {
+            info = this.getAdapter({ incyclistProfile: profile });
         }
         else {
-            return;
-        }
-        const sensor = sensor_factory_1.default.create(profile, Number(deviceID));
-        if (sensor) {
-            const info = profiles.find(i => i.profile === profile);
-            if (!info)
-                return;
-            return new info.Class(sensor, protocol);
+            info = this.getAdapter({ antProfile: profile });
         }
+        if (info && info.Adapter)
+            return new info.Adapter(settings, props);
+    }
+    createFromDetected(profile, deviceID, props) {
+        const info = this.getAdapter({ antProfile: profile });
+        if (!info || !info.Adapter)
+            return;
+        const settings = Object.assign({}, {
+            profile: info.incyclistProfile,
+            deviceID: deviceID.toString(),
+            interface: 'ant',
+            protocol: 'Ant'
+        });
+        return new info.Adapter(settings, props);
     }
 }
-exports.default = AdapterFactory;
+exports.default = AntAdapterFactory;

package/lib/antv2/adapter.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { IChannel, ISensor } from 'incyclist-ant-plus';
+import AntInterface from './ant-interface';
+import IncyclistDevice from '../base/adpater';
+import { AntDeviceProperties, AntDeviceSettings } from './types';
+import { DeviceProperties } from '../types/device';
+import { Bike, IncyclistDeviceAdapter, OnDeviceDataCallback } from '../types/adapter';
+import CyclingMode from '../modes/cycling-mode';
+import { User } from '../types/user';
+export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
+export default class AntAdapter extends IncyclistDevice {
+    sensor: ISensor;
+    lastUpdate?: number;
+    data: any;
+    deviceData: any;
+    updateFrequency: number;
+    channel: IChannel;
+    ant: AntInterface;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
+    onDataFn: OnDeviceDataCallback;
+    startupRetryPause: number;
+    protected ivDataTimeout: NodeJS.Timer;
+    protected lastDataTS: number;
+    protected dataMsgCount: number;
+    protected ivWaitForData: NodeJS.Timer;
+    constructor(settings: AntDeviceSettings, props?: DeviceProperties);
+    createSensor(settings: AntDeviceSettings): ISensor;
+    isEqual(settings: AntDeviceSettings): boolean;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    resetData(): void;
+    isSame(device: IncyclistDeviceAdapter): boolean;
+    hasData(): boolean;
+    onDeviceData(deviceData: any): void;
+    waitForData(timeout: number): Promise<unknown>;
+    getID(): string;
+    getName(): string;
+    getInterface(): string;
+    getProfile(): string;
+    startDataTimeoutCheck(): void;
+    stopDataTimeoutCheck(): void;
+    check(): Promise<boolean>;
+    checkCapabilities(): Promise<void>;
+    initControl(): Promise<void>;
+    start(props?: AntDeviceProperties): Promise<boolean>;
+    stop(): Promise<boolean>;
+}
+export declare class ControllableAntAdapter extends AntAdapter implements Bike {
+    cyclingMode: CyclingMode;
+    user?: User;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    setUser(user: User): void;
+    setBikeProps(props: DeviceProperties): void;
+    getWeight(): number;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+}

package/lib/antv2/adapter.js

@@ -0,0 +1,299 @@
+"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 __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 });
+exports.ControllableAntAdapter = exports.DEFAULT_UPDATE_FREQUENCY = void 0;
+const ant_interface_1 = __importDefault(require("./ant-interface"));
+const adpater_1 = __importStar(require("../base/adpater"));
+const utils_1 = require("../utils/utils");
+const capabilities_1 = require("../types/capabilities");
+const adpater_2 = require("../base/adpater");
+const utils_2 = require("./utils");
+exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+const NO_DATA_TIMEOUT = 5000;
+const INTERFACE_NAME = 'ant';
+class AntAdapter extends adpater_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.startupRetryPause = 1000;
+        if (this.settings.interface !== 'ant')
+            throw new Error('Incorrect interface');
+        this.sensor = this.createSensor(settings);
+        this.deviceData = {};
+        this.data = {};
+        this.dataMsgCount = 0;
+        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
+        this.channel = undefined;
+        this.ant = ant_interface_1.default.getInstance();
+    }
+    createSensor(settings) {
+        throw new Error('Method not implemented.');
+    }
+    isEqual(settings) {
+        const as = this.settings;
+        if (as.interface !== settings.interface)
+            return false;
+        if (as.deviceID != settings.deviceID || as.profile !== settings.profile)
+            return false;
+        return true;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connected = yield ant_interface_1.default.getInstance().connect();
+            return connected;
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+    resetData() {
+        this.dataMsgCount = 0;
+        const { DeviceID } = this.deviceData;
+        this.deviceData = { DeviceID };
+        this.lastDataTS = undefined;
+    }
+    isSame(device) {
+        if (!(device instanceof AntAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
+    }
+    hasData() {
+        return this.dataMsgCount > 0;
+    }
+    onDeviceData(deviceData) {
+        const { ManId } = this.deviceData;
+        this.deviceData = Object.assign({}, deviceData);
+        if (!ManId && deviceData.ManId) {
+            this.emit('device-info', { manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
+        }
+    }
+    waitForData(timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTs = Date.now();
+            const timeoutTs = startTs + timeout;
+            if (this.hasData())
+                return true;
+            return new Promise((resolve, reject) => {
+                if (this.ivWaitForData)
+                    return reject(new Error('busy'));
+                this.ivWaitForData = setInterval(() => {
+                    const nowTs = Date.now();
+                    const hasData = this.hasData();
+                    if (nowTs > timeoutTs && !hasData) {
+                        clearInterval(this.ivWaitForData);
+                        this.ivWaitForData = undefined;
+                        reject(new Error('No Data Received'));
+                    }
+                    if (hasData) {
+                        clearInterval(this.ivWaitForData);
+                        this.ivWaitForData = undefined;
+                        resolve(true);
+                    }
+                }, 500);
+            });
+        });
+    }
+    getID() {
+        return this.sensor.getDeviceID().toString();
+    }
+    getName() {
+        const deviceID = this.sensor.getDeviceID();
+        const profile = this.sensor.getProfile();
+        return `Ant+${profile} ${deviceID}`;
+    }
+    getInterface() {
+        return INTERFACE_NAME;
+    }
+    getProfile() {
+        const settings = this.settings;
+        return settings.profile;
+    }
+    startDataTimeoutCheck() {
+        if (this.ivDataTimeout)
+            return;
+        this.ivDataTimeout = setInterval(() => {
+            if (!this.lastDataTS)
+                return;
+            if (this.lastDataTS + NO_DATA_TIMEOUT < Date.now()) {
+                this.emit('disconnected', Date.now() - this.lastDataTS);
+            }
+        }, 1000);
+    }
+    stopDataTimeoutCheck() {
+        if (!this.ivDataTimeout)
+            return;
+        clearInterval(this.ivDataTimeout);
+        this.ivDataTimeout = undefined;
+        this.lastDataTS = undefined;
+        this.dataMsgCount = 0;
+    }
+    check() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.start();
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+    checkCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    initControl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started)
+                return true;
+            const connected = yield this.connect();
+            if (!connected)
+                throw new Error(`could not start device, reason:could not connect`);
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.resetData();
+                this.stopped = false;
+                const { startupTimeout = 20000 } = props;
+                let to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        yield this.stop();
+                    }
+                    catch (_a) { }
+                    this.started = false;
+                    reject(new Error(`could not start device, reason:timeout`));
+                }), startupTimeout);
+                let started = false;
+                do {
+                    started = yield this.ant.startSensor(this.sensor, (data) => {
+                        this.onDeviceData(data);
+                    });
+                    if (!started)
+                        yield (0, utils_1.sleep)(this.startupRetryPause);
+                } while (!started);
+                try {
+                    yield this.waitForData(startupTimeout - 100);
+                    yield this.checkCapabilities();
+                    if (this.hasCapability(capabilities_1.IncyclistCapability.Control))
+                        yield this.initControl();
+                    this.started = true;
+                    if (to)
+                        clearTimeout(to);
+                    resolve(true);
+                }
+                catch (err) {
+                }
+            }));
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopDataTimeoutCheck();
+            let stopped = yield this.ant.stopSensor(this.sensor);
+            if (!stopped)
+                return false;
+            this.started = false;
+            this.stopped = true;
+            this.removeAllListeners();
+            return true;
+        });
+    }
+}
+exports.default = AntAdapter;
+class ControllableAntAdapter extends AntAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.user = {};
+    }
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = adpater_2.DEFAULT_USER_WEIGHT;
+    }
+    setBikeProps(props) {
+        const { user, userWeight, bikeWeight } = props || {};
+        if (user)
+            this.setUser(user);
+        if (userWeight)
+            this.user.weight = userWeight;
+        const keys = Object.keys(props);
+        keys.forEach(k => {
+            const p = props[k];
+            if (p === null)
+                delete this.props[k];
+            else if (p !== undefined)
+                this.props[k] = p;
+        });
+    }
+    getWeight() {
+        const { user = {}, props = adpater_2.DEFAULT_PROPS } = this;
+        const userWeight = user.weight || props.userWeight || adpater_2.DEFAULT_USER_WEIGHT;
+        const bikeWeight = props.bikeWeight || adpater_1.DEFAULT_BIKE_WEIGHT;
+        return userWeight + bikeWeight;
+    }
+    getSupportedCyclingModes() { throw new Error('not implemented'); }
+    getDefaultCyclingMode() { throw new Error('not implemented'); }
+    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);
+    }
+    getCyclingMode() {
+        if (!this.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.cyclingMode;
+    }
+}
+exports.ControllableAntAdapter = ControllableAntAdapter;

package/lib/antv2/ant-interface.d.ts

@@ -2,15 +2,16 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import AntDeviceBinding from "./ant-binding";
-import { AntScannerProps } from "./incyclist-protocol";
-export declare type AntInterfaceProps = {
-    binding?: typeof AntDeviceBinding;
-    logger?: EventLogger;
+import { InterfaceProps } from "../types/interface";
+import AntDeviceBinding from "./binding";
+import { IncyclistInterface } from "../types/interface";
+import { AntDeviceSettings, AntScanProps } from "./types";
+export interface AntInterfaceProps extends InterfaceProps {
     startupTimeout?: number;
-};
-export default class AntInterface extends EventEmitter {
+}
+export default class AntInterface extends EventEmitter implements IncyclistInterface {
     static _instance: AntInterface;
+    static INTERFACE_NAME: string;
     static getInstance(props?: AntInterfaceProps): AntInterface;
     static hasInstance(): boolean;
     protected logger: EventLogger;
@@ -21,15 +22,16 @@ export default class AntInterface extends EventEmitter {
     protected props: AntInterfaceProps;
     protected activeScan: IChannel;
     constructor(props: AntInterfaceProps);
+    getName(): string;
     getBinding(): typeof AntDeviceBinding;
     setBinding(binding: typeof AntDeviceBinding): void;
     setLogger(logger: EventLogger): void;
     logEvent(event: any): void;
-    connect(): Promise<unknown>;
+    connect(): Promise<boolean>;
     disconnect(): Promise<boolean>;
     onError(profile: any, error: any): void;
     onData(profile: any, id: any, data: any, tag: any): void;
-    scan(props?: AntScannerProps): Promise<unknown>;
+    scan(props?: AntScanProps): Promise<AntDeviceSettings[]>;
     stopScan(): Promise<boolean>;
     startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
     stopSensor(sensor: ISensor): Promise<boolean>;

package/lib/antv2/ant-interface.js

@@ -16,6 +16,14 @@ const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
 const sensor_factory_1 = __importDefault(require("./sensor-factory"));
 class AntInterface extends events_1.default {
+    static getInstance(props = {}) {
+        if (AntInterface._instance === undefined)
+            AntInterface._instance = new AntInterface(props);
+        return AntInterface._instance;
+    }
+    static hasInstance() {
+        return AntInterface._instance !== undefined;
+    }
     constructor(props) {
         super();
         this.props = props;
@@ -32,13 +40,8 @@ class AntInterface extends events_1.default {
             this.Binding = binding;
         }
     }
-    static getInstance(props = {}) {
-        if (AntInterface._instance === undefined)
-            AntInterface._instance = new AntInterface(props);
-        return AntInterface._instance;
-    }
-    static hasInstance() {
-        return AntInterface._instance !== undefined;
+    getName() {
+        return AntInterface.INTERFACE_NAME;
     }
     getBinding() {
         return this.Binding;
@@ -94,10 +97,10 @@ class AntInterface extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device)
                 return true;
-            this.logEvent({ message: 'disconnecting ...' });
+            this.logEvent({ message: 'ANT+ disconnecting ...' });
             const closed = yield this.device.close();
             this.isConnected = !closed;
-            this.logEvent({ message: 'disconnected' });
+            this.logEvent({ message: 'ANT+ disconnected' });
             return closed;
         });
     }
@@ -119,8 +122,8 @@ class AntInterface extends events_1.default {
             const onDetected = (profile, deviceID) => {
                 if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
                     try {
-                        detected.push({ profile, deviceID });
-                        this.emit('detected', profile, deviceID);
+                        detected.push({ interface: this.getName(), profile, deviceID });
+                        this.emit('device', profile, deviceID);
                     }
                     catch (err) {
                         this.logEvent({ message: 'error', fn: 'onDerected', error: err.message, stack: err.stack });
@@ -267,3 +270,4 @@ class AntInterface extends events_1.default {
 }
 exports.default = AntInterface;
 AntInterface._instance = undefined;
+AntInterface.INTERFACE_NAME = 'ant';

package/lib/antv2/fe/adapter.d.ts

@@ -0,0 +1,25 @@
+import { ISensor } from "incyclist-ant-plus";
+import { ControllableAntAdapter } from "../adapter";
+import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
+import { AntDeviceProperties, AntDeviceSettings } from "../types";
+export default class AntFEAdapter extends ControllableAntAdapter {
+    static INCYCLIST_PROFILE_NAME: string;
+    static ANT_PROFILE_NAME: string;
+    protected distanceInternal?: number;
+    protected startProps: AntDeviceProperties;
+    protected isReconnecting: boolean;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    createSensor(settings: AntDeviceSettings): ISensor;
+    getName(): string;
+    getDisplayName(): string;
+    getSupportedCyclingModes(): Array<any>;
+    getDefaultCyclingMode(): CyclingMode;
+    getLogData(data: any, excludeList: any): any;
+    sendUpdate(request: any): Promise<void>;
+    onDeviceData(deviceData: any): void;
+    mapData(deviceData: any): IncyclistBikeData;
+    transformData(bikeData: any): any;
+    start(props?: any): Promise<any>;
+    setFEDefaultTimeout(): void;
+    reconnect(): Promise<boolean>;
+}