incyclist-devices 1.4.26 → 1.4.27

package/lib/CyclingMode.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CyclingModeBase = exports.CyclingModeProperyType = void 0;
 var CyclingModeProperyType;
 (function (CyclingModeProperyType) {
     CyclingModeProperyType["Integer"] = "Integer";

package/lib/Device.d.ts

@@ -49,7 +49,7 @@ export interface DeviceAdapter extends Device {
     sendUpdate(request: any): void;
     onData(callback: OnDeviceDataCallback): void;
 }
-export default class DeviceAdapterBase implements DeviceAdapter {
+export default class IncyclistDevice implements DeviceAdapter {
     protocol: DeviceProtocol;
     detected: boolean;
     selected: boolean;

package/lib/Device.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
-class DeviceAdapterBase {
+class IncyclistDevice {
     constructor(proto) {
         this.protocol = proto;
         this.detected = false;
@@ -43,4 +42,4 @@ class DeviceAdapterBase {
         this.onDataFn = callback;
     }
 }
-exports.default = DeviceAdapterBase;
+exports.default = IncyclistDevice;

package/lib/DeviceProtocol.d.ts

@@ -16,7 +16,7 @@ export declare type Device = {
 };
 export interface DeviceSettings {
     name: string;
-    port: string;
+    port?: string;
     userSettings?: User;
     bikeSettings?: any;
 }
@@ -64,6 +64,7 @@ export default class DeviceProtocolBase {
     getSerialPort(): void;
     setNetImpl(netClass: any): void;
     getNetImpl(): any;
+    setBinding(_bindingClass: any): void;
     static setAnt(antClass: any): void;
     static getAnt(): any;
     static setSerialPort(serialClass: any): void;

package/lib/DeviceProtocol.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INTERFACE = void 0;
 exports.INTERFACE = {
     SERIAL: 'serial',
     ANT: 'ant',
@@ -30,6 +29,7 @@ class DeviceProtocolBase {
     getSerialPort() { DeviceProtocolBase.getSerialPort(); }
     setNetImpl(netClass) { DeviceProtocolBase.setNetImpl(netClass); }
     getNetImpl() { return DeviceProtocolBase.getNetImpl(); }
+    setBinding(_bindingClass) { }
     static setAnt(antClass) { _ant = antClass; }
     static getAnt() { return _ant; }
     static setSerialPort(serialClass) { _serial = serialClass; }

package/lib/DeviceSupport.d.ts

@@ -6,11 +6,16 @@ import DaumPremiumProtocol from './daum/premium/DaumPremiumProtocol';
 import DaumClassicProtocol from './daum/classic/DaumClassicProtocol';
 import KettlerRacerProtocol from './kettler/ergo-racer/protocol';
 import { AntScanner } from './ant/AntScanner';
+import BleProtocol from './ble/incyclist-protocol';
 import { CyclingModeProperyType } from './CyclingMode';
+import BleInterface from './ble/ble-interface';
+import BleHrmDevice from './ble/hrm';
+import BleCyclingPowerDevice from './ble/pwr';
 declare const Protocols: {
     SimulatorProtocol: typeof SimulatorProtocol;
     DaumClassicProtocol: typeof DaumClassicProtocol;
     DaumPremiumProtocol: typeof DaumPremiumProtocol;
     KettlerRacerProtocol: typeof KettlerRacerProtocol;
+    BleProtocol: typeof BleProtocol;
 };
-export { DeviceProtocolBase, DeviceProtocol, DeviceRegistry, INTERFACE, DeviceAdapter as Device, Protocols, AntScanner, CyclingModeProperyType };
+export { DeviceProtocolBase, DeviceProtocol, DeviceRegistry, INTERFACE, DeviceAdapter as Device, Protocols, AntScanner, BleProtocol, CyclingModeProperyType, BleInterface, BleHrmDevice, BleCyclingPowerDevice };

package/lib/DeviceSupport.js

@@ -1,47 +1,43 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 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);
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CyclingModeProperyType = exports.AntScanner = exports.Protocols = exports.Device = exports.INTERFACE = exports.DeviceRegistry = exports.DeviceProtocolBase = void 0;
 const DeviceRegistry_1 = __importDefault(require("./DeviceRegistry"));
 exports.DeviceRegistry = DeviceRegistry_1.default;
 const Device_1 = __importDefault(require("./Device"));
 exports.Device = Device_1.default;
 const DeviceProtocol_1 = __importStar(require("./DeviceProtocol"));
 exports.DeviceProtocolBase = DeviceProtocol_1.default;
-Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return DeviceProtocol_1.INTERFACE; } });
+exports.INTERFACE = DeviceProtocol_1.INTERFACE;
 const Simulator_1 = __importDefault(require("./simulator/Simulator"));
 const DaumPremiumProtocol_1 = __importDefault(require("./daum/premium/DaumPremiumProtocol"));
 const DaumClassicProtocol_1 = __importDefault(require("./daum/classic/DaumClassicProtocol"));
 const protocol_1 = __importDefault(require("./kettler/ergo-racer/protocol"));
 const AntScanner_1 = require("./ant/AntScanner");
-Object.defineProperty(exports, "AntScanner", { enumerable: true, get: function () { return AntScanner_1.AntScanner; } });
+exports.AntScanner = AntScanner_1.AntScanner;
+const incyclist_protocol_1 = __importDefault(require("./ble/incyclist-protocol"));
+exports.BleProtocol = incyclist_protocol_1.default;
 const CyclingMode_1 = require("./CyclingMode");
-Object.defineProperty(exports, "CyclingModeProperyType", { enumerable: true, get: function () { return CyclingMode_1.CyclingModeProperyType; } });
+exports.CyclingModeProperyType = CyclingMode_1.CyclingModeProperyType;
+const ble_interface_1 = __importDefault(require("./ble/ble-interface"));
+exports.BleInterface = ble_interface_1.default;
+const hrm_1 = __importDefault(require("./ble/hrm"));
+exports.BleHrmDevice = hrm_1.default;
+const pwr_1 = __importDefault(require("./ble/pwr"));
+exports.BleCyclingPowerDevice = pwr_1.default;
 const Protocols = {
     SimulatorProtocol: Simulator_1.default,
     DaumClassicProtocol: DaumClassicProtocol_1.default,
     DaumPremiumProtocol: DaumPremiumProtocol_1.default,
     KettlerRacerProtocol: protocol_1.default,
+    BleProtocol: incyclist_protocol_1.default
 };
 exports.Protocols = Protocols;

package/lib/ant/AntAdapter.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_UPDATE_FREQUENCY = void 0;
 const Device_1 = __importDefault(require("../Device"));
 exports.DEFAULT_UPDATE_FREQUENCY = 1000;
 class AntAdapter extends Device_1.default {

package/lib/ant/AntScanner.js

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -27,11 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntScanner = exports.AntProtocol = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
 const AntHrmAdapter_1 = __importDefault(require("./anthrm/AntHrmAdapter"));

package/lib/ant/antfe/AntFEAdapter.js

@@ -52,7 +52,7 @@ class AntFEAdapter extends AntAdapter_1.default {
     getDisplayName() {
         const { DeviceID, ManId, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}${hrmStr}`;
+        return `${utils_1.getBrand(ManId)} FE ${DeviceID}${hrmStr}`;
     }
     onAttached() {
         this.logger.logEvent({ message: 'Device connected' });
@@ -233,7 +233,7 @@ class AntFEAdapter extends AntAdapter_1.default {
                                 trackResistanceSent: false,
                                 userSent: false,
                             };
-                            (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+                            utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
                                 if (this.isStopped())
                                     resolve(false);
                                 try {
@@ -299,18 +299,18 @@ class AntFEAdapter extends AntAdapter_1.default {
             try {
                 const isReset = (!request || request.reset || Object.keys(request).length === 0);
                 if (request.slope !== undefined) {
-                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
+                    yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
                 }
                 if (request.targetPower !== undefined) {
-                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
+                    yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
                 }
                 else if (request.maxPower !== undefined) {
                     if (this.data.power && this.data.power > request.maxPower)
-                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.maxPower); }), 2, 100);
+                        yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.maxPower); }), 2, 100);
                 }
                 else if (request.minPower !== undefined) {
                     if (this.data.power && this.data.power < request.minPower)
-                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.minPower); }), 2, 100);
+                        yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.minPower); }), 2, 100);
                 }
             }
             catch (err) {
@@ -395,7 +395,7 @@ class AntFEAdapter extends AntAdapter_1.default {
             this.currentCmd = this.queue.dequeue();
             this.currentCmd.tsStart = Date.now();
             const { msg, logStr } = this.currentCmd;
-            this.logger.logEvent({ message: "sending", cmd: logStr, msg: (0, utils_2.hexstr)(msg), queueSize: this.queue.size() });
+            this.logger.logEvent({ message: "sending", cmd: logStr, msg: utils_2.hexstr(msg), queueSize: this.queue.size() });
             if (this.stick)
                 this.stick.write(msg);
         }

package/lib/ant/anthrm/AntHrmAdapter.js

@@ -43,7 +43,7 @@ class AntHrmAdapter extends AntAdapter_1.default {
     getDisplayName() {
         const { DeviceID, manID, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${(0, utils_1.getBrand)(manID)} Hrm ${DeviceID}${hrmStr}`;
+        return `${utils_1.getBrand(manID)} Hrm ${DeviceID}${hrmStr}`;
     }
     onDeviceData(deviceData) {
         if (!this.started)

package/lib/ant/antpwr/pwr-adapter.js

@@ -48,7 +48,7 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     getDisplayName() {
         const { DeviceID, ManId } = this.deviceData;
-        return `${(0, utils_1.getBrand)(ManId)} PWR ${DeviceID}`;
+        return `${utils_1.getBrand(ManId)} PWR ${DeviceID}`;
     }
     getCyclingMode() {
         if (!this.mode)

package/lib/ant/utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrand = void 0;
-const getBrand = (manId) => {
+exports.getBrand = (manId) => {
     if (manId === undefined)
         return "ANT+";
     switch (manId) {
@@ -20,4 +19,3 @@ const getBrand = (manId) => {
             return "ANT+";
     }
 };
-exports.getBrand = getBrand;

package/lib/ble/ble-device.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { EventLogger } from "gd-eventlog";
+import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleCharacteristic, BleDeviceProps, ConnectProps } from "./ble";
+interface ConnectState {
+    isConnecting: boolean;
+    isConnected: boolean;
+    isDisconnecting: boolean;
+}
+interface BleDeviceConstructProps extends BleDeviceProps {
+    log?: boolean;
+    logger?: EventLogger;
+}
+export declare abstract class BleDevice extends BleDeviceClass {
+    id: string;
+    address: string;
+    name: string;
+    services: string[];
+    ble: BleInterfaceClass;
+    peripheral?: BlePeripheral;
+    characteristics: BleCharacteristic[];
+    state?: string;
+    connectState: ConnectState;
+    logger?: EventLogger;
+    constructor(props?: BleDeviceConstructProps);
+    logEvent(event: any): void;
+    setInterface(ble: BleInterfaceClass): void;
+    private cleanupListeners;
+    private onDisconnect;
+    connect(props?: ConnectProps): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    abstract getProfile(): string;
+    abstract onData(characteristic: string, data: Buffer): void;
+    abstract write(characteristic: string, data: Buffer): Promise<boolean>;
+    abstract read(characteristic: string): Promise<Buffer>;
+}
+export {};

package/lib/ble/ble-device.js

@@ -0,0 +1,174 @@
+"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 ble_1 = require("./ble");
+class BleDevice extends ble_1.BleDeviceClass {
+    constructor(props) {
+        super();
+        this.characteristics = [];
+        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
+        this.id = props.id;
+        this.address = props.address;
+        this.name = props.name;
+        this.services = props.services;
+        this.ble = props.ble;
+        this.characteristics = [];
+        if (props.peripheral) {
+            const { id, address, advertisement, state } = props.peripheral;
+            this.peripheral = props.peripheral;
+            this.id = id;
+            this.address = address;
+            this.name = advertisement.localName;
+            this.services = advertisement.serviceUuids;
+            this.state = state;
+        }
+        if (props.logger) {
+            this.logger = props.logger;
+        }
+        else if (props.log) {
+            this.logger = new gd_eventlog_1.EventLogger('BleDevice');
+        }
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        if (process.env.BLE_DEBUG) {
+            console.log(event);
+        }
+    }
+    setInterface(ble) {
+        this.ble = ble;
+    }
+    cleanupListeners() {
+        if (this.characteristics === undefined) {
+            this.characteristics = [];
+        }
+        else {
+            this.characteristics.forEach(c => {
+                c.removeAllListeners('data');
+            });
+            this.characteristics = [];
+        }
+    }
+    onDisconnect() {
+        this.state = "disconnected";
+        if (!this.connectState.isDisconnecting) {
+            this.connect();
+        }
+        this.emit('disconnected');
+    }
+    connect(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectPeripheral = (peripheral) => __awaiter(this, void 0, void 0, function* () {
+                this.connectState.isConnecting = true;
+                try {
+                    yield peripheral.connectAsync();
+                }
+                catch (err) {
+                    this.logEvent({ message: 'cannot connect', error: err.message || err });
+                }
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = true;
+                this.state = "connected";
+                this.emit('connected');
+                this.cleanupListeners();
+                this.ble.addConnectedDevice(this);
+                this.peripheral.once('disconnect', () => { this.onDisconnect(); });
+                try {
+                    const { characteristics } = yield peripheral.discoverSomeServicesAndCharacteristicsAsync(this.services || [], []);
+                    characteristics.forEach(c => {
+                        if (c.properties.find(p => p === 'notify')) {
+                            c.on('data', (data, _isNotification) => {
+                                this.onData(c.uuid, data);
+                            });
+                            c.subscribe((err) => {
+                                if (err)
+                                    this.logEvent({ message: 'cannot subscribe', error: err.message || err });
+                            });
+                        }
+                    });
+                }
+                catch (err) {
+                    this.logEvent({ message: 'cannot connect', error: err.message || err });
+                }
+            });
+            try {
+                if (this.peripheral) {
+                    const { id, address, advertisement } = this.peripheral;
+                    const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
+                    this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
+                    yield connectPeripheral(this.peripheral);
+                    this.logEvent({ message: 'connect result: success', mode: 'peripheral', device: { id, name, address } });
+                    return true;
+                }
+                else {
+                    const { id, name, address } = this;
+                    if (this.address || this.id || this.name) {
+                        this.connectState.isConnecting = true;
+                        this.logEvent({ message: 'connect requested', mode: 'device', device: { id, name, address } });
+                        try {
+                            if (this.ble.isScanning()) {
+                                yield this.ble.stopScan();
+                            }
+                            const devices = yield this.ble.scan({ device: this });
+                            if (devices && devices.length > 0) {
+                                this.peripheral = devices[0].peripheral;
+                                yield connectPeripheral(this.peripheral);
+                                this.logEvent({ message: 'connect result: success', mode: 'device', device: { id, name, address } });
+                                return true;
+                            }
+                        }
+                        catch (err) {
+                        }
+                    }
+                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address } });
+                    this.connectState.isConnecting = false;
+                    this.connectState.isConnected = false;
+                    return false;
+                }
+            }
+            catch (err) {
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                this.logEvent({ message: 'connect result: error', error: err.message });
+                return false;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { id, name, address } = this;
+            this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
+            this.connectState.isDisconnecting = true;
+            if (!this.connectState.isConnecting && !this.connectState.isConnected) {
+                this.connectState.isDisconnecting = false;
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                return true;
+            }
+            if (this.connectState.isConnecting) {
+                this.cleanupListeners();
+                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
+                this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
+                return true;
+            }
+            if (this.connectState.isConnected) {
+                this.ble.removeConnectedDevice(this);
+                this.cleanupListeners();
+                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                return true;
+            }
+        });
+    }
+}
+exports.BleDevice = BleDevice;

package/lib/ble/ble-interface.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import { EventLogger } from 'gd-eventlog';
+import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BleBinding } from './ble';
+export interface ScanState {
+    isScanning: boolean;
+    timeout?: NodeJS.Timeout;
+}
+export interface ConnectState {
+    isConnecting: boolean;
+    isConnected: boolean;
+    timeout?: NodeJS.Timeout;
+    isOpened: boolean;
+}
+export interface BleDeviceInfo {
+    device: BleDeviceClass;
+    isConnected: boolean;
+}
+export interface BleDeviceClassInfo {
+    Class: typeof BleDeviceClass;
+    type: string;
+    services: string[];
+    id: string;
+}
+export default class BleInterface extends BleInterfaceClass {
+    scanState: ScanState;
+    connectState: ConnectState;
+    devices: BleDeviceInfo[];
+    logger: EventLogger;
+    static deviceClasses: BleDeviceClassInfo[];
+    constructor(props?: {
+        binding?: BleBinding;
+        log?: boolean;
+        logger?: EventLogger;
+    });
+    static register(id: string, type: string, Class: typeof BleDeviceClass, services: string[]): void;
+    logEvent(event: any): void;
+    onStateChange(state: any): void;
+    onError(err: any): void;
+    connect(props?: ConnectProps): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
+    getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
+    getServicesFromDevice(device: BleDeviceClass): string[];
+    connectDevice(requested: BleDeviceClass, timeout?: number): Promise<BleDeviceClass>;
+    scan(props: ScanProps): Promise<BleDeviceClass[]>;
+    stopScan(): Promise<boolean>;
+    isScanning(): boolean;
+    addConnectedDevice(device: BleDeviceClass): void;
+    removeConnectedDevice(device: BleDeviceClass): void;
+}