incyclist-devices 2.3.10 → 2.3.12

package/lib/ble/fm/comms.js

@@ -1,506 +0,0 @@
-"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 consts_1 = require("../consts");
-const comms_1 = require("../base/comms");
-const utils_1 = require("../utils");
-const bit = (nr) => (1 << nr);
-const IndoorBikeDataFlag = {
-    MoreData: bit(0),
-    AverageSpeedPresent: bit(1),
-    InstantaneousCadence: bit(2),
-    AverageCadencePresent: bit(3),
-    TotalDistancePresent: bit(4),
-    ResistanceLevelPresent: bit(5),
-    InstantaneousPowerPresent: bit(6),
-    AveragePowerPresent: bit(7),
-    ExpendedEnergyPresent: bit(8),
-    HeartRatePresent: bit(9),
-    MetabolicEquivalentPresent: bit(10),
-    ElapsedTimePresent: bit(11),
-    RemainingTimePresent: bit(12)
-};
-const FitnessMachineFeatureFlag = {
-    AverageSpeedSupported: bit(0),
-    CadenceSupported: bit(1),
-    TotalDistanceSupported: bit(2),
-    InclinationSupported: bit(3),
-    ElevationGainSupported: bit(4),
-    PaceSupported: bit(5),
-    StepCountSupported: bit(6),
-    ResistanceLevelSupported: bit(7),
-    StrideCountSupported: bit(8),
-    ExpendedEnergySupported: bit(9),
-    HeartRateMeasurementSupported: bit(10),
-    MetabolicEquivalentSupported: bit(11),
-    ElapsedTimeSupported: bit(12),
-    RemainingTimeSupported: bit(13),
-    PowerMeasurementSupported: bit(14),
-    ForceOnBeltAndPowerOutputSupported: bit(15),
-    UserDataRetentionSupported: bit(16)
-};
-const TargetSettingFeatureFlag = {
-    SpeedTargetSettingSupported: bit(0),
-    InclinationTargetSettingSupported: bit(1),
-    ResistanceTargetSettingSupported: bit(2),
-    PowerTargetSettingSupported: bit(3),
-    HeartRateTargetSettingSupported: bit(4),
-    TargetedExpendedEnergyConfigurationSupported: bit(5),
-    TargetedStepNumberConfigurationSupported: bit(6),
-    TargetedStrideNumberConfigurationSupported: bit(7),
-    TargetedDistanceConfigurationSupported: bit(8),
-    TargetedTrainingTimeConfigurationSupported: bit(9),
-    TargetedTimeInTwoHeartRateZonesConfigurationSupported: bit(10),
-    TargetedTimeInThreeHeartRateZonesConfigurationSupported: bit(11),
-    TargetedTimeInFiveHeartRateZonesConfigurationSupported: bit(12),
-    IndoorBikeSimulationParametersSupported: bit(13),
-    WheelCircumferenceConfigurationSupported: bit(14),
-    SpinDownControlSupported: bit(15),
-    TargetedCadenceConfigurationSupported: bit(16)
-};
-class BleFitnessMachineDevice extends comms_1.BleComms {
-    constructor(props) {
-        super(props);
-        this.features = undefined;
-        this.hasControl = false;
-        this.isCheckingControl = false;
-        this.isCPSubscribed = false;
-        this.crr = 0.0033;
-        this.cw = 0.6;
-        this.windSpeed = 0;
-        this.wheelSize = 2100;
-        this.reset();
-        this.services = BleFitnessMachineDevice.services;
-    }
-    static isMatching(characteristics) {
-        if (!characteristics)
-            return false;
-        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
-        const hasStatus = announced.find(c => c === consts_1.FTMS_STATUS) !== undefined;
-        const hasCP = announced.find(c => c === consts_1.FTMS_CP) !== undefined;
-        const hasIndoorBike = announced.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
-        return hasStatus && hasCP && hasIndoorBike;
-    }
-    subscribeWriteResponse(cuuid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'subscribe to CP response', characteristics: cuuid });
-            const connector = this.ble.peripheralCache.getConnector(this.peripheral);
-            const isAlreadySubscribed = connector.isSubscribed(cuuid);
-            if (!isAlreadySubscribed) {
-                connector.removeAllListeners(cuuid);
-                let prev = undefined;
-                let prevTS = undefined;
-                connector.on(cuuid, (uuid, data) => {
-                    const message = data.toString('hex');
-                    if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
-                        return;
-                    }
-                    prevTS = Date.now();
-                    prev = message;
-                    this.onData(uuid, data);
-                });
-                yield connector.subscribe(cuuid);
-            }
-        });
-    }
-    subscribeAll(conn) {
-        const characteristics = [consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP];
-        if (!this.features || (this.features && this.features.cadence))
-            characteristics.push(consts_1.CSC_MEASUREMENT);
-        if (!this.features || (this.features && this.features.power))
-            characteristics.push(consts_1.CSP_MEASUREMENT);
-        if (!this.features || (this.features && this.features.heartrate))
-            characteristics.push(consts_1.HR_MEASUREMENT);
-        return this.subscribeMultiple(characteristics, conn);
-    }
-    init() {
-        const _super = Object.create(null, {
-            initDevice: { get: () => super.initDevice }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield _super.initDevice.call(this);
-                yield this.getFitnessMachineFeatures();
-                this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'BleFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    onDisconnect() {
-        const _super = Object.create(null, {
-            onDisconnect: { get: () => super.onDisconnect }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            _super.onDisconnect.call(this);
-            this.hasControl = false;
-        });
-    }
-    getProfile() {
-        return 'Smart Trainer';
-    }
-    getProtocol() {
-        return BleFitnessMachineDevice.protocol;
-    }
-    getServiceUUids() {
-        return BleFitnessMachineDevice.services;
-    }
-    parseHrm(_data) {
-        const data = Buffer.from(_data);
-        try {
-            const flags = data.readUInt8(0);
-            if (flags % 1 === 0) {
-                this.data.heartrate = data.readUInt8(1);
-            }
-            else {
-                this.data.heartrate = data.readUInt16LE(1);
-            }
-        }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseHrm()', error: err.message | err, stack: err.stack });
-        }
-        return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
-    }
-    setCrr(crr) { this.crr = crr; }
-    getCrr() { return this.crr; }
-    setCw(cw) { this.cw = cw; }
-    getCw() { return this.cw; }
-    setWindSpeed(windSpeed) { this.windSpeed = windSpeed; }
-    getWindSpeed() { return this.windSpeed; }
-    parseIndoorBikeData(_data) {
-        const data = Buffer.from(_data);
-        try {
-            const flags = data.readUInt16LE(0);
-            let offset = 2;
-            if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
-                this.data.speed = data.readUInt16LE(offset) / 100;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
-                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
-                this.data.cadence = data.readUInt16LE(offset) / 2;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
-                this.data.averageCadence = data.readUInt16LE(offset) / 2;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
-                const dvLow = data.readUInt8(offset);
-                offset += 1;
-                const dvHigh = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.totalDistance = (dvHigh << 8) + dvLow;
-            }
-            if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
-                this.data.resistanceLevel = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
-                this.data.instantaneousPower = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
-                this.data.averagePower = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
-                this.data.totalEnergy = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.energyPerHour = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.energyPerMinute = data.readUInt8(offset);
-                offset += 1;
-            }
-            if (flags & IndoorBikeDataFlag.HeartRatePresent) {
-                this.data.heartrate = data.readUInt8(offset);
-                offset += 1;
-            }
-            if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
-                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
-                this.data.time = data.readUInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
-                this.data.remainingTime = data.readUInt16LE(offset);
-                offset += 2;
-            }
-        }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
-        }
-        return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
-    }
-    parseFitnessMachineStatus(_data) {
-        const data = Buffer.from(_data);
-        try {
-            const OpCode = data.readUInt8(0);
-            switch (OpCode) {
-                case 8:
-                    this.data.targetPower = data.readInt16LE(1);
-                    break;
-                case 6:
-                    this.data.targetInclination = data.readInt16LE(1) / 10;
-                    break;
-                case 4:
-                    this.data.status = "STARTED";
-                    break;
-                case 3:
-                case 2:
-                    this.data.status = "STOPPED";
-                    break;
-                case 20:
-                    const spinDownStatus = data.readUInt8(1);
-                    switch (spinDownStatus) {
-                        case 1:
-                            this.data.status = "SPIN DOWN REQUESTED";
-                            break;
-                        case 2:
-                            this.data.status = "SPIN DOWN SUCCESS";
-                            break;
-                        case 3:
-                            this.data.status = "SPIN DOWN ERROR";
-                            break;
-                        case 4:
-                            this.data.status = "STOP PEDALING";
-                            break;
-                        default: break;
-                    }
-            }
-        }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message | err, stack: err.stack });
-        }
-        return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
-    }
-    getFitnessMachineFeatures() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.features)
-                return this.features;
-            try {
-                const data = yield this.read('2acc');
-                const buffer = data ? Buffer.from(data) : undefined;
-                if (buffer) {
-                    const fitnessMachine = buffer.readUInt32LE(0);
-                    const targetSettings = buffer.readUInt32LE(4);
-                    const power = (fitnessMachine & FitnessMachineFeatureFlag.PowerMeasurementSupported) !== 0;
-                    const heartrate = (fitnessMachine & FitnessMachineFeatureFlag.HeartRateMeasurementSupported) !== 0;
-                    const cadence = (fitnessMachine & FitnessMachineFeatureFlag.CadenceSupported) !== 0;
-                    const setSlope = (targetSettings & TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0
-                        || (targetSettings & TargetSettingFeatureFlag.InclinationTargetSettingSupported) !== 0;
-                    const setPower = (targetSettings & TargetSettingFeatureFlag.PowerTargetSettingSupported) !== 0;
-                    this.features = { fitnessMachine, targetSettings, power, heartrate, cadence, setPower, setSlope };
-                    this.logEvent({ message: 'supported Features: ', fatures: this.features, power, heartrate, cadence });
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack });
-                return undefined;
-            }
-        });
-    }
-    onData(characteristic, data) {
-        const hasData = super.onData(characteristic, data);
-        if (!hasData)
-            return false;
-        const uuid = characteristic.toLocaleLowerCase();
-        let res = undefined;
-        switch (uuid) {
-            case consts_1.INDOOR_BIKE_DATA:
-                res = this.parseIndoorBikeData(data);
-                break;
-            case '2a37':
-                res = this.parseHrm(data);
-                break;
-            case consts_1.FTMS_STATUS:
-                res = this.parseFitnessMachineStatus(data);
-                break;
-            case '2a63':
-            case '2a5b':
-            case '347b0011-7635-408b-8918-8ff3949ce592':
-                break;
-            default:
-                break;
-        }
-        if (res) {
-            this.emit('data', res);
-            return false;
-        }
-        return true;
-    }
-    writeFtmsMessage(requestedOpCode, data, props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
-                const res = yield this.write(consts_1.FTMS_CP, data, props);
-                const responseData = Buffer.from(res);
-                const opCode = responseData.readUInt8(0);
-                const request = responseData.readUInt8(1);
-                const result = responseData.readUInt8(2);
-                if (opCode !== 128 || request !== requestedOpCode)
-                    throw new Error('Illegal response ');
-                this.logEvent({ message: 'fmts:write result', res, result });
-                return result;
-            }
-            catch (err) {
-                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
-                return 4;
-            }
-        });
-    }
-    requestControl() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let to = undefined;
-            if (this.isCheckingControl) {
-                to = setTimeout(() => { }, 3500);
-            }
-            if (this.hasControl)
-                return true;
-            this.logEvent({ message: 'requestControl' });
-            this.isCheckingControl = true;
-            const data = Buffer.alloc(1);
-            data.writeUInt8(0, 0);
-            const res = yield this.writeFtmsMessage(0, data, { timeout: 5000 });
-            if (res === 1) {
-                this.hasControl = true;
-            }
-            else {
-                this.logEvent({ message: 'requestControl failed' });
-            }
-            this.isCheckingControl = false;
-            if (to)
-                clearTimeout(to);
-            return this.hasControl;
-        });
-    }
-    setTargetPower(power) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
-            if (this.data.targetPower !== undefined && this.data.targetPower === power)
-                return true;
-            if (!this.hasControl)
-                return;
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
-                return true;
-            }
-            const data = Buffer.alloc(3);
-            data.writeUInt8(5, 0);
-            data.writeInt16LE(Math.round(power), 1);
-            const res = yield this.writeFtmsMessage(5, data);
-            return (res === 1);
-        });
-    }
-    setSlope(slope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'setSlope', slope });
-            const hasControl = yield this.requestControl();
-            if (!hasControl)
-                return;
-            const { windSpeed, crr, cw } = this;
-            return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
-        });
-    }
-    setTargetInclination(inclination) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.data.targetInclination !== undefined && this.data.targetInclination === inclination)
-                return true;
-            if (!this.hasControl)
-                return;
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(3);
-            data.writeUInt8(3, 0);
-            data.writeInt16LE(Math.round(inclination * 10), 1);
-            const res = yield this.writeFtmsMessage(3, data);
-            return (res === 1);
-        });
-    }
-    setIndoorBikeSimulation(windSpeed, gradient, crr, cw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'setIndoorBikeSimulation failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(7);
-            data.writeUInt8(17, 0);
-            data.writeInt16LE(Math.round(windSpeed * 1000), 1);
-            data.writeInt16LE(Math.round(gradient * 100), 3);
-            data.writeUInt8(Math.round(crr * 10000), 5);
-            data.writeUInt8(Math.round(cw * 100), 6);
-            const res = yield this.writeFtmsMessage(17, data);
-            return (res === 1);
-        });
-    }
-    startRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'startRequest failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(1);
-            data.writeUInt8(7, 0);
-            const res = yield this.writeFtmsMessage(7, data);
-            return (res === 1);
-        });
-    }
-    stopRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'stopRequest failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(2);
-            data.writeUInt8(8, 0);
-            data.writeUInt8(1, 1);
-            const res = yield this.writeFtmsMessage(8, data);
-            return (res === 1);
-        });
-    }
-    PauseRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'PauseRequest failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(2);
-            data.writeUInt8(8, 0);
-            data.writeUInt8(2, 1);
-            const res = yield this.writeFtmsMessage(8, data);
-            return (res === 1);
-        });
-    }
-    reset() {
-        this.data = {};
-    }
-}
-BleFitnessMachineDevice.protocol = 'fm';
-BleFitnessMachineDevice.services = [consts_1.FTMS];
-BleFitnessMachineDevice.characteristics = ['2acc', consts_1.INDOOR_BIKE_DATA, '2ad6', '2ad8', consts_1.FTMS_CP, consts_1.FTMS_STATUS];
-BleFitnessMachineDevice.detectionPriority = 100;
-exports.default = BleFitnessMachineDevice;

package/lib/ble/hr/comm.d.ts

@@ -1,19 +0,0 @@
-import { LegacyProfile } from '../../antv2/types';
-import { BleComms } from '../base/comms';
-import { BleProtocol } from '../types';
-import { HrmData } from './types';
-export default class BleHrmDevice extends BleComms {
-    static protocol: BleProtocol;
-    static services: string[];
-    static characteristics: string[];
-    static detectionPriority: number;
-    heartrate: number;
-    rr: number;
-    constructor(props?: any);
-    getProfile(): LegacyProfile;
-    getProtocol(): BleProtocol;
-    getServiceUUids(): string[];
-    static isMatching(characteristics: string[]): boolean;
-    parseHrm(_data: Uint8Array): HrmData;
-    onData(characteristic: string, data: Buffer): boolean;
-}

package/lib/ble/hr/comm.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const comms_1 = require("../base/comms");
-const consts_1 = require("../consts");
-const utils_1 = require("../utils");
-class BleHrmDevice extends comms_1.BleComms {
-    constructor(props) {
-        super(props);
-        this.heartrate = undefined;
-        this.rr = undefined;
-    }
-    getProfile() {
-        return 'Heartrate Monitor';
-    }
-    getProtocol() {
-        return BleHrmDevice.protocol;
-    }
-    getServiceUUids() {
-        return BleHrmDevice.services;
-    }
-    static isMatching(characteristics) {
-        if (!characteristics)
-            return false;
-        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
-        const hasHRMeasurement = announced.find(c => c === consts_1.HR_MEASUREMENT) !== undefined;
-        return hasHRMeasurement;
-    }
-    parseHrm(_data) {
-        const data = Buffer.from(_data);
-        try {
-            const flags = data.readUInt8(0);
-            let offset = 2;
-            if (flags % 1 === 0) {
-                this.heartrate = data.readUInt8(1);
-            }
-            else {
-                this.heartrate = data.readUInt16LE(1);
-                offset = 3;
-            }
-            if (flags % 0xF) {
-                this.rr = (data.readUInt16LE(offset)) / 1024;
-            }
-        }
-        catch (err) {
-        }
-        const { heartrate, rr } = this;
-        return { heartrate, rr, raw: data.toString('hex') };
-    }
-    onData(characteristic, data) {
-        const hasData = super.onData(characteristic, data);
-        if (!hasData)
-            return;
-        if (characteristic.toLocaleLowerCase() === '2a37') {
-            const res = this.parseHrm(data);
-            this.emit('data', res);
-            return false;
-        }
-        return true;
-    }
-}
-BleHrmDevice.protocol = 'hr';
-BleHrmDevice.services = ['180d'];
-BleHrmDevice.characteristics = [consts_1.HR_MEASUREMENT, '2a38', '2a39', '2a3c'];
-BleHrmDevice.detectionPriority = 1;
-exports.default = BleHrmDevice;

package/lib/ble/peripheral-cache.d.ts

@@ -1,45 +0,0 @@
-import BleAdapter from "./base/adapter";
-import { BleComms } from "./base/comms";
-import { BleDeviceData } from "./base/types";
-import BlePeripheralConnector from "./ble-peripheral";
-import { BleCharacteristic, BlePeripheral } from "./types";
-export interface PeripheralState {
-    isLoading: boolean;
-    isConfigured: boolean;
-    isInterrupted: boolean;
-}
-export interface PeripheralCacheItem {
-    address: string;
-    name?: string;
-    id?: string;
-    ts: number;
-    peripheral: BlePeripheral;
-    state?: PeripheralState;
-    characteristics?: BleCharacteristic[];
-    connector?: BlePeripheralConnector;
-}
-export default class BlePeripheralCache {
-    peripherals: PeripheralCacheItem[];
-    findAdapter(adapter: BleAdapter<BleDeviceData, BleComms>): PeripheralCacheItem;
-    getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
-    getPeripheral(query: {
-        id?: string;
-        address?: string;
-        name?: string;
-    }): BlePeripheral;
-    handleStopScan(): void;
-    find(query: {
-        name?: string;
-        id?: string;
-        address?: string;
-        peripheral?: BlePeripheral;
-    }): PeripheralCacheItem;
-    filter(services: string[]): PeripheralCacheItem[];
-    protected _findIndex(query: {
-        name?: string;
-        id?: string;
-        address?: string;
-    }): number;
-    add(item: PeripheralCacheItem): PeripheralCacheItem;
-    remove(query: PeripheralCacheItem | BlePeripheral): void;
-}