incyclist-devices 1.5.38 → 2.0.0

package/lib/antv2/pwr/adapter.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = require("../adapter");
+const utils_1 = require("../utils");
+const gd_eventlog_1 = require("gd-eventlog");
+const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+const sensor_factory_1 = __importDefault(require("../sensor-factory"));
+const capabilities_1 = require("../../types/capabilities");
+class AntPwrAdapter extends adapter_1.ControllableAntAdapter {
+    constructor(settings, props) {
+        if (settings.protocol && settings.profile !== AntPwrAdapter.INCYCLIST_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        if (!settings.protocol && settings.profile !== AntPwrAdapter.ANT_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        super(settings, props);
+        this.deviceData = {
+            DeviceID: this.sensor.getDeviceID()
+        };
+        this.logger = new gd_eventlog_1.EventLogger('Ant+PWR');
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Speed
+        ];
+    }
+    createSensor(settings) {
+        return sensor_factory_1.default.create(AntPwrAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
+    }
+    getName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const deviceID = this.sensor.getDeviceID();
+        return `Ant+PWR ${deviceID}`;
+    }
+    getUniqueName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const { DeviceID, ManId } = this.deviceData;
+        const brand = (0, utils_1.getBrand)(ManId);
+        if (brand)
+            return `${brand} PWR ${DeviceID}`;
+        else
+            return `${this.getName()}`;
+    }
+    getDisplayName() {
+        const { Power } = this.deviceData;
+        const pwrStr = Power ? ` (${Power})` : '';
+        return `${this.getUniqueName()}${pwrStr}`;
+    }
+    getDefaultCyclingMode() {
+        return new power_meter_1.default(this);
+    }
+    getSupportedCyclingModes() {
+        return [power_meter_1.default];
+    }
+    getLogData(data, excludeList) {
+        const logData = JSON.parse(JSON.stringify(data));
+        excludeList.forEach((key) => {
+            delete logData[key];
+        });
+        return logData;
+    }
+    onDeviceData(deviceData) {
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
+        super.onDeviceData(deviceData);
+        if (!this.started)
+            return;
+        if (!this.ivDataTimeout)
+            this.startDataTimeoutCheck();
+        try {
+            if (!this.canSendUpdate())
+                return;
+            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
+            this.logger.logEvent({ message: 'onDeviceData', data: logData });
+            let incyclistData = this.mapData(deviceData);
+            incyclistData = this.getCyclingMode().updateData(incyclistData);
+            const data = this.transformData(incyclistData);
+            this.emitData(data);
+        }
+        catch (err) {
+        }
+    }
+    canSendUpdate() {
+        if (!this.hasDataListeners() || this.paused)
+            return false;
+        return super.canSendUpdate();
+    }
+    sendUpdate(request) {
+        if (this.isPaused())
+            return;
+        this.getCyclingMode().sendBikeUpdate(request);
+    }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: 0,
+            speed: 0,
+            heartrate: 0,
+            distanceInternal: 0,
+            slope: undefined,
+            time: undefined
+        };
+        data.slope = (deviceData.Slope !== undefined ? deviceData.Slope : data.slope);
+        data.power = (deviceData.Power !== undefined ? deviceData.Power : data.power);
+        data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
+        data.time = (deviceData.TimeStamp !== undefined ? deviceData.TimeStamp : data.time);
+        data.isPedalling = data.pedalRpm > 0;
+        return data;
+    }
+    transformData(bikeData) {
+        if (bikeData === undefined)
+            return;
+        let distance = 0;
+        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
+            distance = bikeData.distanceInternal - this.distanceInternal;
+        }
+        if (bikeData.distanceInternal !== undefined)
+            this.distanceInternal = bikeData.distanceInternal;
+        let data = {
+            speed: bikeData.speed,
+            slope: bikeData.slope,
+            power: bikeData.power,
+            cadence: bikeData.pedalRpm,
+            distance,
+            timestamp: Date.now()
+        };
+        return data;
+    }
+    hasData() {
+        const { Power, Cadence, TimeStamp } = this.deviceData;
+        return Power !== undefined && Power !== null ||
+            Cadence !== undefined || Cadence !== null ||
+            TimeStamp !== undefined || TimeStamp !== null;
+    }
+}
+exports.default = AntPwrAdapter;
+AntPwrAdapter.INCYCLIST_PROFILE_NAME = 'Power Meter';
+AntPwrAdapter.ANT_PROFILE_NAME = 'PWR';

package/lib/antv2/pwr/index.d.ts

@@ -0,0 +1,2 @@
+import AntPwrAdapter from './adapter';
+export default AntPwrAdapter;

package/lib/antv2/pwr/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("./adapter"));
+exports.default = adapter_1.default;

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

@@ -1,5 +1,5 @@
-import { ISensor } from "incyclist-ant-plus";
+import { ISensor, Profile } from "incyclist-ant-plus";
 export default class SensorFactory {
-    static create(profile: string, deviceID?: number): ISensor;
+    static create(profile: Profile, deviceID?: number): ISensor;
     static createAll(): ISensor[];
 }

package/lib/antv2/types.d.ts

@@ -0,0 +1,22 @@
+import { Profile } from 'incyclist-ant-plus';
+import IncyclistDevice from '../base/adpater';
+import { DeviceProperties, DeviceSettings, IncyclistScanProps } from '../types/device';
+export interface AntDeviceSettings extends DeviceSettings {
+    deviceID?: string;
+    profile: Profile | LegacyProfile;
+    protocol?: string;
+}
+export type LegacyProfile = 'Heartrate Monitor' | 'Power Meter' | 'Smart Trainer' | 'Speed Sensor' | 'Cadence Sensor' | 'Speed + Cadence Sensor';
+export declare const isLegacyProfile: (o: unknown) => boolean;
+export type DeviceFoundCallback = (device: IncyclistDevice, protocol: string) => void;
+export type ScanFinishedCallback = (id: number) => void;
+export interface AntScanProps extends IncyclistScanProps {
+    profiles?: Profile[];
+    id?: number;
+    onDeviceFound?: DeviceFoundCallback;
+    onScanFinished?: ScanFinishedCallback;
+}
+export interface AntDeviceProperties extends DeviceProperties {
+    startupTimeout?: number;
+    automaticReconnect?: boolean;
+}

package/lib/antv2/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegacyProfile = void 0;
+const isLegacyProfile = (o) => o === 'Heartrate Monitor' || o === 'Power Meter' || o === 'Smart Trainer' || o === 'Speed Sensor' || o === 'Cadence Sensor' || o === 'Speed + Cadence Sensor';
+exports.isLegacyProfile = isLegacyProfile;

package/lib/antv2/utils.d.ts

@@ -0,0 +1,4 @@
+import { Profile } from "incyclist-ant-plus";
+import { LegacyProfile } from "./types";
+export declare const getBrand: (manId: number) => string;
+export declare const mapLegacyProfile: (legacy: LegacyProfile) => Profile;

package/lib/antv2/utils.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapLegacyProfile = exports.getBrand = void 0;
+const brands = [
+    'Garmin,1',
+    'garmin_fr405_antfs,2',
+    'Zephyr,3',
+    'Dayton,4',
+    'idt,5',
+    'SRM,6',
+    'Quarq,7',
+    'ibike,8',
+    'Saris,9',
+    'spark_hk,10',
+    'Tanita,11',
+    'echowell,12',
+    'Dynastream_oem,13',
+    'Nautilus,14',
+    'Dynastream,15',
+    'Timex,16',
+    'Metrigear,17',
+    'Xelic,18',
+    'Beurer,19',
+    'Cardiosport,20',
+    'A&D,21',
+    'Hmm,22',
+    'Suunto,23',
+    'Thita Elektronik,24',
+    'Gpulse,25',
+    'Clean Mobile,26',
+    'Pedal Brain,27',
+    'Peaksware,28',
+    'Saxonar,29',
+    'Lemond Fitness,30',
+    'Dexcom,31',
+    'Wahoo,32',
+    'Octane,33',
+    'Archinoetics,34',
+    'The Hurt Box,35',
+    'Citizen Systems,36',
+    'Magellan,37',
+    'Osynce,38',
+    'Holux,39',
+    'Concept2,40',
+    'One Giant Leap,42',
+    'Ace Sensor,43',
+    'Brim Brothers,44',
+    'Xplova,45',
+    'Perception Digital,46',
+    'Bf1systems,47',
+    'Pioneer,48',
+    'Spantec,49',
+    'Metalogics,50',
+    '4iiiis,51',
+    'Seiko,52',
+    'Seiko,53',
+    'Ifor Powell,54',
+    'Maxwell Guider,55',
+    'Star rac,56',
+    'Breakaway,57',
+    'Alatech,58',
+    'Mio,59',
+    'Rotor,60',
+    'Geonaute,61',
+    'Id Bike,62',
+    'Specialized,63',
+    'Wtek,64',
+    'Physical Enterprises,65',
+    'North Pole,66',
+    'Bkool,67',
+    'Cateye,68',
+    'Stages,69',
+    'Sigma,70',
+    'Tomtom,71',
+    'Peripedal,72',
+    'Wattbike,73',
+    'Moxy,76',
+    'Ciclosport,77',
+    'Powerbahn,78',
+    'Acorn,79',
+    'Lifebeam,80',
+    'Bontrager,81',
+    'Wellgo,82',
+    'Scosche,83',
+    'Magura,84',
+    'Woodway,85',
+    'Elite,86',
+    'Nielsen Kellerman,87',
+    'DK City,88',
+    'Tacx,89',
+    'Direction,90',
+    'Magtonic,91',
+    '1partcarbon,92',
+    'Inside Ride,93',
+    'Sound Of Motion,94',
+    'Stryd,95',
+    'icg,96',
+    'MiPulse,97',
+    'Bsx Athletics,98',
+    'Look,99',
+    'Campagnolo,100',
+    'Body Bike Smart,101',
+    'Praxisworks,102',
+    'Limits,103',
+    'Topaction,104',
+    'Cosinuss,105',
+    'Fitcare,106',
+    'Magene,107',
+    'Giant,108',
+    'Tigrasport,109',
+    'Salutron,110',
+    'Technogym,111',
+    'Bryton,112',
+    'Latitude,113',
+    'Soaring,114',
+    'Igpsport,115',
+    'Thinkrider,116',
+    'Gopher,117',
+    'Waterrower,118',
+    'Orangetheory,119',
+    'Inpeak,120',
+    'Kinetic,121',
+    'Johnson,122',
+    'Polar,123',
+    'Seesense,124',
+    'NCI,125',
+    'Development,255',
+    'Healthandlife,257',
+    'Lezyne,258',
+    'Scribe,259',
+    'Zwift,260',
+    'Watteam,261',
+    'Recon,262',
+    'Favero,263',
+    'Dynovelo,264',
+    'Strava,265',
+    'Precor,266',
+    'Bryton,267',
+    'Sram,268',
+    'Navman,269',
+    'Cobi,270',
+    'Spivi,271',
+    'Mio Magellan,272',
+    'Evesports,273',
+    'Sensitivus Gauge,274',
+    'Podoon,275',
+    'Life Time Fitness,276',
+    'Falco,277',
+    'Minoura,278',
+    'Cycliq,279',
+    'Luxottica,280',
+    'Trainer Road,281',
+    'The Sufferfest,282',
+    'Fullspeedahead,283',
+    'Virtualtraining,284',
+    'Feedbacksports,285',
+    'Omata,286',
+    'VDO,287',
+    'Magneticdays,288',
+    'Hammerhead,289',
+    'Kinetic By Kurt,290',
+    'Shapelog,291',
+    'Dabuziduo,292',
+    'Jetblack,293',
+    'Coros,294',
+    'Virtugo,295',
+    'Velosense,296',
+    'Cycligentinc,297',
+    'Actigraphcorp,5759'
+];
+const brandLookup = brands.map(str => {
+    const [name, id] = str.split(',');
+    return { name, id: Number(id) };
+});
+const getBrand = (manId) => {
+    const found = brandLookup.find(l => l.id === manId);
+    if (found)
+        return found.name;
+    return;
+};
+exports.getBrand = getBrand;
+const mapLegacyProfile = (legacy) => {
+    switch (legacy) {
+        case 'Heartrate Monitor': return 'HR';
+        case 'Power Meter': return 'PWR';
+        case 'Smart Trainer': return 'FE';
+        case 'Cadence Sensor': return 'CAD';
+        case 'Speed Sensor': return 'SPD';
+        case 'Speed + Cadence Sensor': return 'SC';
+    }
+};
+exports.mapLegacyProfile = mapLegacyProfile;

package/lib/base/adpater.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+import CyclingMode from "../modes/cycling-mode";
+import { DeviceProperties, DeviceSettings } from "../types/device";
+import { Bike, IncyclistDeviceAdapter, OnDeviceDataCallback } from '../types/adapter';
+import { User } from "../types/user";
+import { IncyclistCapability } from "../types/capabilities";
+import { EventLogger } from "gd-eventlog";
+import { DeviceData } from "../types/data";
+import EventEmitter from "events";
+export declare const DEFAULT_BIKE_WEIGHT = 10;
+export declare const DEFAULT_USER_WEIGHT = 75;
+export declare const DEFAULT_PROPS: DeviceProperties;
+export default class IncyclistDevice extends EventEmitter implements IncyclistDeviceAdapter {
+    onDataFn: OnDeviceDataCallback;
+    settings: DeviceSettings;
+    props: DeviceProperties;
+    lastUpdate?: number;
+    updateFrequency: number;
+    capabilities: IncyclistCapability[];
+    protected logger: EventLogger;
+    started: boolean;
+    stopped: boolean;
+    paused: boolean;
+    constructor(settings: DeviceSettings, props?: DeviceProperties);
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    check(): Promise<boolean>;
+    isControllable(): boolean;
+    isEqual(settings: DeviceSettings): boolean;
+    getCapabilities(): IncyclistCapability[];
+    hasCapability(capability: IncyclistCapability): boolean;
+    addCapability(capability: IncyclistCapability): void;
+    update(): void;
+    start(props?: DeviceProperties): Promise<boolean>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    logEvent(event: any): void;
+    getMaxUpdateFrequency(): number;
+    setMaxUpdateFrequency(value: number): void;
+    sendUpdate(request: any): void;
+    getID(): string;
+    getDisplayName(): string;
+    getName(): string;
+    getUniqueName(): string;
+    getSettings(): DeviceSettings;
+    getInterface(): string;
+    onData(callback: OnDeviceDataCallback): void;
+    canSendUpdate(): boolean;
+    emitData(data: DeviceData): void;
+    isStopped(): boolean;
+    isStarted(): boolean;
+    isPaused(): boolean;
+    hasDataListeners(): boolean | OnDeviceDataCallback;
+}
+export declare class ControllableDevice extends IncyclistDevice implements Bike {
+    cyclingMode: CyclingMode;
+    user?: User;
+    constructor(settings: DeviceSettings, props?: DeviceProperties);
+    isControllable(): boolean;
+    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/base/adpater.js

@@ -0,0 +1,183 @@
+"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 });
+exports.ControllableDevice = exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+const events_1 = __importDefault(require("events"));
+exports.DEFAULT_BIKE_WEIGHT = 10;
+exports.DEFAULT_USER_WEIGHT = 75;
+exports.DEFAULT_PROPS = {
+    userWeight: exports.DEFAULT_USER_WEIGHT,
+    bikeWeight: exports.DEFAULT_BIKE_WEIGHT
+};
+class IncyclistDevice extends events_1.default {
+    constructor(settings, props) {
+        super();
+        this.onDataFn = undefined;
+        this.settings = settings;
+        this.props = props || {};
+        this.capabilities = [];
+        this.started = false;
+        this.stopped = false;
+        this.paused = false;
+    }
+    connect() { throw new Error('not implemented'); }
+    close() { throw new Error('not implemented'); }
+    check() { throw new Error("Method not implemented."); }
+    isControllable() {
+        return false;
+    }
+    isEqual(settings) { throw new Error("Method not implemented."); }
+    getCapabilities() { return this.capabilities; }
+    hasCapability(capability) {
+        return this.capabilities.find(c => c === capability) !== undefined;
+    }
+    addCapability(capability) {
+        if (!this.capabilities.includes(capability))
+            this.capabilities.push(capability);
+    }
+    update() { throw new Error("Method not implemented."); }
+    start(props) { throw new Error("Method not implemented."); }
+    stop() { throw new Error("Method not implemented."); }
+    pause() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.paused = true;
+            return true;
+        });
+    }
+    resume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.paused = false;
+            return true;
+        });
+    }
+    logEvent(event) {
+        if (!this.logger || this.paused)
+            return;
+        this.logger.logEvent(event);
+    }
+    getMaxUpdateFrequency() {
+        return this.updateFrequency;
+    }
+    setMaxUpdateFrequency(value) {
+        this.updateFrequency = value;
+    }
+    sendUpdate(request) { throw new Error("Method not implemented."); }
+    getID() { throw new Error('not implemented'); }
+    getDisplayName() {
+        return this.getName();
+    }
+    getName() {
+        return this.settings.name;
+    }
+    getUniqueName() {
+        throw new Error("Method not implemented.");
+    }
+    getSettings() {
+        return this.settings;
+    }
+    getInterface() {
+        return typeof this.settings.interface === 'string' ? this.settings.interface : this.settings.interface.getName();
+    }
+    onData(callback) {
+        this.onDataFn = callback;
+    }
+    canSendUpdate() {
+        const updateFrequency = this.getMaxUpdateFrequency();
+        if (updateFrequency === -1 || updateFrequency === undefined)
+            return true;
+        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+    }
+    emitData(data) {
+        if (!this.canSendUpdate())
+            return;
+        if (this.onDataFn)
+            this.onDataFn(data);
+        this.emit('data', this.getSettings(), data);
+        this.lastUpdate = Date.now();
+    }
+    isStopped() {
+        return this.stopped;
+    }
+    isStarted() {
+        return this.started;
+    }
+    isPaused() {
+        return this.paused;
+    }
+    hasDataListeners() {
+        return this.onDataFn || this.listenerCount('data') > 0;
+    }
+}
+exports.default = IncyclistDevice;
+class ControllableDevice extends IncyclistDevice {
+    constructor(settings, props) {
+        super(settings, props);
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.user = {};
+    }
+    isControllable() {
+        return true;
+    }
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = exports.DEFAULT_USER_WEIGHT;
+    }
+    setBikeProps(props) {
+        const { user, userWeight } = 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 = 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) {
+        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.ControllableDevice = ControllableDevice;

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

@@ -0,0 +1,33 @@
+import { DeviceProperties } from "../types/device";
+import BleAdapter from "./base/adapter";
+import { BleDeviceSettings, BleProtocol } from "./types";
+import { BleComms } from "./base/comms";
+export interface BleAdapterInfo {
+    protocol: BleProtocol;
+    Adapter: typeof BleAdapter;
+    Comm: typeof BleComms;
+}
+export default class BleAdapterFactory {
+    static _instance: BleAdapterFactory;
+    implementations: BleAdapterInfo[];
+    instances: BleAdapter[];
+    static getInstance(): BleAdapterFactory;
+    constructor();
+    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
+    getAll(): BleAdapterInfo[];
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter;
+    removeInstance(query: {
+        settings?: BleDeviceSettings;
+        adapter?: BleAdapter;
+    }): void;
+    find(settings?: BleDeviceSettings): BleAdapter;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter, Comm: typeof BleComms): void;
+    getAllInstances(): BleAdapter[];
+    getAllSupportedComms(): (typeof BleComms)[];
+    getAllSupportedAdapters(): (typeof BleAdapter)[];
+    getAllSupportedServices(): string[];
+    getDeviceClasses(peripheral: any, props?: {
+        protocol?: BleProtocol;
+        services?: string[];
+    }): (typeof BleComms)[];
+}